Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: AccessOutputData extends BaseStepData implements StepDataInterface { void createTable( String tableName, RowMetaInterface rowMeta ) throws IOException { List<Column> columns = AccessOutputMeta.getColumns( rowMeta ); db.createTable( tableName, columns ); table = db.getTable( tableName ); } AccessOutputData(); public Database db; public Table table; public List<Object[]> rows; public RowMetaInterface outputRowMeta; public boolean oneFileOpened; }### Answer: @Test public void testCreateTable() throws IOException { data.createDatabase( mdbFile ); data.createTable( "thisSampleTable", generateRowMeta() ); assertTrue( data.db.getTableNames().contains( "thisSampleTable" ) ); data.closeDatabase(); }
### Question: AccessOutputData extends BaseStepData implements StepDataInterface { void truncateTable() throws IOException { if ( table == null ) { return; } Cursor tableRows = Cursor.createCursor( table ); while ( tableRows.moveToNextRow() ) { tableRows.deleteCurrentRow(); } } AccessOutputData(); public Database db; public Table table; public List<Object[]> rows; public RowMetaInterface outputRowMeta; public boolean oneFileOpened; }### Answer: @Test public void testTruncateTable() throws IOException { data.createDatabase( mdbFile ); data.createTable( "TruncatingThisTable", generateRowMeta() ); data.addRowsToTable( generateRowData( 10 ) ); assertEquals( 10, data.table.getRowCount() ); data.truncateTable(); assertEquals( 0, data.table.getRowCount() ); data.addRowToTable( generateRowData( 1 ).get( 0 ) ); assertEquals( 1, data.table.getRowCount() ); data.closeDatabase(); }
### Question: ActingPrincipal implements Principal, Serializable { public boolean isAnonymous() { return anonymous; } ActingPrincipal( String name ); private ActingPrincipal(); @Override String getName(); boolean equals( Object other ); String toString(); int hashCode(); boolean isAnonymous(); static final ActingPrincipal ANONYMOUS; }### Answer: @Test public void isAnonymous() throws Exception { assertTrue( ActingPrincipal.ANONYMOUS.isAnonymous() ); assertFalse( new ActingPrincipal( "harold" ).isAnonymous() ); assertFalse( new ActingPrincipal( "" ).isAnonymous() ); }
### Question: IfNullMeta extends BaseStepMeta implements StepMetaInterface { public void setDefault() { replaceAllByValue = null; replaceAllMask = null; selectFields = false; selectValuesType = false; setEmptyStringAll = false; int nrfields = 0; int nrtypes = 0; allocate( nrtypes, nrfields ); } IfNullMeta(); boolean isSetEmptyStringAll(); void setEmptyStringAll( boolean setEmptyStringAll ); void loadXML( Node stepnode, List<DatabaseMeta> databases, IMetaStore metaStore ); Object clone(); void allocate( int nrtypes, int nrfields ); boolean isSelectFields(); void setSelectFields( boolean selectFields ); void setSelectValuesType( boolean selectValuesType ); boolean isSelectValuesType(); void setReplaceAllByValue( String replaceValue ); String getReplaceAllByValue(); void setReplaceAllMask( String replaceAllMask ); String getReplaceAllMask(); Fields[] getFields(); void setFields( Fields[] fields ); ValueTypes[] getValueTypes(); void setValueTypes( ValueTypes[] valueTypes ); String getXML(); void setDefault(); void readRep( Repository rep, IMetaStore metaStore, ObjectId id_step, List<DatabaseMeta> databases ); void saveRep( Repository rep, IMetaStore metaStore, ObjectId id_transformation, ObjectId id_step ); void check( List<CheckResultInterface> remarks, TransMeta transMeta, StepMeta stepMeta, RowMetaInterface prev, String[] input, String[] output, RowMetaInterface info, VariableSpace space, Repository repository, IMetaStore metaStore ); StepInterface getStep( StepMeta stepMeta, StepDataInterface stepDataInterface, int cnr, TransMeta tr, Trans trans ); StepDataInterface getStepData(); boolean supportsErrorHandling(); }### Answer: @Test public void testSetDefault() throws Exception { IfNullMeta inm = new IfNullMeta(); inm.setDefault(); assertTrue( ( inm.getValueTypes() != null ) && ( inm.getValueTypes().length == 0 ) ); assertTrue( ( inm.getFields() != null ) && ( inm.getFields().length == 0 ) ); assertFalse( inm.isSelectFields() ); assertFalse( inm.isSelectValuesType() ); }
### Question: MemoryGroupByData extends BaseStepData implements StepDataInterface { public HashEntry getHashEntry( Object[] groupData ) { return new HashEntry( groupData ); } MemoryGroupByData(); HashEntry getHashEntry( Object[] groupData ); void clear(); public HashMap<HashEntry, Aggregate> map; public RowMetaInterface aggMeta; public RowMetaInterface groupMeta; public RowMetaInterface entryMeta; public RowMetaInterface groupAggMeta; public int[] groupnrs; public int[] subjectnrs; public boolean firstRead; public Object[] groupResult; public boolean hasOutput; public RowMetaInterface inputRowMeta; public RowMetaInterface outputRowMeta; public ValueMetaInterface valueMetaInteger; public ValueMetaInterface valueMetaNumber; public boolean newBatch; }### Answer: @Test public void hashEntryTest() { HashMap<MemoryGroupByData.HashEntry, String> map = new HashMap<>(); byte[] byteValue1 = "key".getBytes(); Object[] groupData1 = new Object[1]; groupData1[0] = byteValue1; MemoryGroupByData.HashEntry hashEntry1 = data.getHashEntry( groupData1 ); map.put( hashEntry1, "value" ); byte[] byteValue2 = "key".getBytes(); Object[] groupData2 = new Object[1]; groupData2[0] = byteValue2; MemoryGroupByData.HashEntry hashEntry2 = data.getHashEntry( groupData2 ); String value = map.get( hashEntry2 ); assertEquals( "value", value ); }
### Question: NamedClusterEmbedManager { public void clear() { NamedClusterServiceOsgi ncso = meta.getNamedClusterServiceOsgi(); if ( ncso != null ) { addedAllClusters = false; addedAnyClusters = false; if ( embeddedMetaStoreFactory != null ) { try { List<NamedClusterOsgi> list = embeddedMetaStoreFactory.getElements(); for ( NamedClusterOsgi nc : list ) { namedClusterPool.put( nc.getName(), nc ); embeddedMetaStoreFactory.deleteElement( nc.getName() ); } } catch ( MetaStoreException e ) { logMetaStoreException( e ); } } } } NamedClusterEmbedManager( AbstractMeta meta, LogChannelInterface log ); void registerUrl( String urlString ); void clear(); boolean isAddedAnyClusters(); void addClusterToMeta( String clusterName ); void passEmbeddedMetastoreKey( VariableSpace nameSpace, String embeddedMetastoreProviderKey ); static final String NAMESPACE; }### Answer: @Test public void testClear() throws Exception { when( mockMetaStoreFactory.getElements() ) .thenReturn( Arrays.asList( new NamedClusterOsgi[] { mockNamedCluster1, mockNamedCluster2 } ) ); namedClusterEmbedManager.clear( ); verify( mockMetaStoreFactory ).deleteElement( CLUSTER1_NAME ); verify( mockMetaStoreFactory ).deleteElement( CLUSTER2_NAME ); }
### Question: NamedClusterEmbedManager { public void passEmbeddedMetastoreKey( VariableSpace nameSpace, String embeddedMetastoreProviderKey ) { if ( nameSpace != null ) { if ( embeddedMetastoreProviderKey != null ) { nameSpace.setVariable( "vfs.hc.embeddedMetastoreKey", embeddedMetastoreProviderKey ); } } } NamedClusterEmbedManager( AbstractMeta meta, LogChannelInterface log ); void registerUrl( String urlString ); void clear(); boolean isAddedAnyClusters(); void addClusterToMeta( String clusterName ); void passEmbeddedMetastoreKey( VariableSpace nameSpace, String embeddedMetastoreProviderKey ); static final String NAMESPACE; }### Answer: @Test public void testPassEmbeddedMetastoreKey() { Variables mockVariables = mock( Variables.class ); namedClusterEmbedManager.passEmbeddedMetastoreKey( mockVariables, "key" ); verify( mockVariables ).setVariable( anyString(), anyString() ); }
### Question: NamedClusterEmbedManager { public void addClusterToMeta( String clusterName ) { NamedClusterServiceOsgi ncso = meta.getNamedClusterServiceOsgi(); if ( ncso != null ) { NamedClusterOsgi nc = ncso.getNamedClusterByName( clusterName, meta.getMetaStore() ); if ( nc == null ) { nc = namedClusterPool.get( clusterName ); } if ( nc != null ) { addClusterToMeta( nc ); } } } NamedClusterEmbedManager( AbstractMeta meta, LogChannelInterface log ); void registerUrl( String urlString ); void clear(); boolean isAddedAnyClusters(); void addClusterToMeta( String clusterName ); void passEmbeddedMetastoreKey( VariableSpace nameSpace, String embeddedMetastoreProviderKey ); static final String NAMESPACE; }### Answer: @Test public void testAddingClusterToMetaData() throws MetaStoreException { namedClusterEmbedManager.addClusterToMeta( CLUSTER1_NAME ); verify( mockMetaStoreFactory ).saveElement( mockNamedCluster1 ); }
### Question: GroupBy extends BaseStep implements StepInterface { @Override public void dispose( StepMetaInterface smi, StepDataInterface sdi ) { if ( data.tempFile != null ) { try { closeInput(); closeOutput(); } catch ( KettleFileException e ) { log.logError( e.getLocalizedMessage() ); } boolean tempFileDeleted = data.tempFile.delete(); if ( !tempFileDeleted && log.isDetailed() ) { log.logDetailed( BaseMessages.getString( PKG, "GroupBy.Exception.UnableToDeleteTemporaryFile", data.tempFile.getPath() ) ); } } super.dispose( smi, sdi ); } GroupBy( StepMeta stepMeta, StepDataInterface stepDataInterface, int copyNr, TransMeta transMeta, Trans trans ); @Override boolean processRow( StepMetaInterface smi, StepDataInterface sdi ); @Override boolean init( StepMetaInterface smi, StepDataInterface sdi ); @Override void dispose( StepMetaInterface smi, StepDataInterface sdi ); @Override void batchComplete(); GroupByMeta getMeta(); }### Answer: @Test public void testTempFileIsDeleted_AfterCallingDisposeMethod() throws Exception { GroupByData groupByData = new GroupByData(); groupByData.tempFile = File.createTempFile( "test", ".txt" ); groupByData.fosToTempFile = new FileOutputStream( groupByData.tempFile ); groupByData.fisToTmpFile = new FileInputStream( groupByData.tempFile ); GroupBy groupBySpy = Mockito.spy( new GroupBy( mockHelper.stepMeta, groupByData, 0, mockHelper.transMeta, mockHelper.trans ) ); assertTrue( groupByData.tempFile.exists() ); groupBySpy.dispose( mock( StepMetaInterface.class ), groupByData ); assertFalse( groupByData.tempFile.exists() ); }
### Question: StaxPoiSheet implements KSheet { @Override public KCell getCell( int colnr, int rownr ) { if ( rownr == 0 && colnr < headerRow.size() ) { return new StaxPoiCell( headerRow.get( colnr ), rownr ); } KCell[] row = getRow( rownr ); if ( row != null && rownr < row.length ) { return row[colnr]; } return null; } StaxPoiSheet( XSSFReader reader, String sheetName, String sheetID ); @Override KCell[] getRow( int rownr ); @Override String getName(); @Override int getRows(); @Override KCell getCell( int colnr, int rownr ); void close(); }### Answer: @Test public void testReadCells() throws Exception { KSheet sheet = getSampleSheet(); KCell cell = sheet.getCell( 1, 2 ); assertEquals( "One", cell.getValue() ); assertEquals( KCellType.LABEL, cell.getType() ); cell = sheet.getCell( 2, 2 ); assertEquals( KCellType.DATE, cell.getType() ); assertEquals( new Date( 1283817600000L ), cell.getValue() ); cell = sheet.getCell( 1, 3 ); assertEquals( "Two", cell.getValue() ); assertEquals( KCellType.LABEL, cell.getType() ); }
### Question: GetPropertiesServlet extends BodyHttpServlet { @Override public String getContextPath() { return CONTEXT_PATH; } @Override String getContextPath(); static final String CONTEXT_PATH; }### Answer: @Test public void getContextPath() throws Exception { GetPropertiesServlet servlet = new GetPropertiesServlet(); servlet.setJettyMode( true ); HttpServletRequest mockHttpServletRequest = mock( HttpServletRequest.class ); HttpServletResponse mockHttpServletResponse = mock( HttpServletResponse.class ); StringWriter out = new StringWriter(); PrintWriter printWriter = new PrintWriter( out ); when( mockHttpServletRequest.getContextPath() ).thenReturn( GetPropertiesServlet.CONTEXT_PATH ); when( mockHttpServletRequest.getParameter( "xml" ) ).thenReturn( "Y" ); when( mockHttpServletResponse.getWriter() ).thenReturn( printWriter ); when( mockHttpServletResponse.getOutputStream() ).thenReturn( new ServletOutputStream() { private ByteArrayOutputStream baos = new ByteArrayOutputStream(); @Override public void write( int b ) throws IOException { baos.write( b ); } public String toString() { return baos.toString(); } } ); servlet.doGet( mockHttpServletRequest, mockHttpServletResponse ); Assert.assertFalse( mockHttpServletResponse.getOutputStream().toString() .startsWith( "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" ) ); }
### Question: RowProducer { public boolean putRowWait( RowMetaInterface rowMeta, Object[] rowData, long time, TimeUnit tu ) { return rowSet.putRowWait( rowMeta, rowData, time, tu ); } RowProducer( StepInterface stepInterface, RowSet rowSet ); void putRow( RowMetaInterface rowMeta, Object[] row ); boolean putRow( RowMetaInterface rowMeta, Object[] row, boolean block ); boolean putRowWait( RowMetaInterface rowMeta, Object[] rowData, long time, TimeUnit tu ); void finished(); RowSet getRowSet(); void setRowSet( RowSet rowSet ); StepInterface getStepInterface(); void setStepInterface( StepInterface stepInterface ); }### Answer: @Test public void testPutRowWait() throws Exception { rowProducer.putRowWait( rowMeta, rowData, 1, TimeUnit.MILLISECONDS ); verify( rowSet, times( 1 ) ).putRowWait( rowMeta, rowData, 1, TimeUnit.MILLISECONDS ); }
### Question: RowProducer { public void finished() { rowSet.setDone(); } RowProducer( StepInterface stepInterface, RowSet rowSet ); void putRow( RowMetaInterface rowMeta, Object[] row ); boolean putRow( RowMetaInterface rowMeta, Object[] row, boolean block ); boolean putRowWait( RowMetaInterface rowMeta, Object[] rowData, long time, TimeUnit tu ); void finished(); RowSet getRowSet(); void setRowSet( RowSet rowSet ); StepInterface getStepInterface(); void setStepInterface( StepInterface stepInterface ); }### Answer: @Test public void testFinished() throws Exception { rowProducer.finished(); verify( rowSet, times( 1 ) ).setDone(); }
### Question: Pan { protected static void configureParameters( Trans trans, NamedParams optionParams, TransMeta transMeta ) throws UnknownParamException { trans.initializeVariablesFrom( null ); trans.getTransMeta().setInternalKettleVariables( trans ); String[] transParams = trans.listParameters(); for ( String param : transParams ) { String value = optionParams.getParameterValue( param ); if ( value != null ) { trans.setParameterValue( param, value ); transMeta.setParameterValue( param, value ); } } trans.activateParameters(); } static void main( String[] a ); }### Answer: @Test public void testConfigureParameters() throws Exception { TransMeta transMeta = new TransMeta(); transMeta.addParameterDefinition( TEST_PARAM_NAME, DEFAULT_PARAM_VALUE, "This tests a default parameter" ); assertEquals( "Default parameter was not set correctly on TransMeta", DEFAULT_PARAM_VALUE, transMeta.getParameterDefault( TEST_PARAM_NAME ) ); assertEquals( "Parameter value should be blank in TransMeta", "", transMeta.getParameterValue( TEST_PARAM_NAME ) ); Trans trans = new Trans( transMeta ); assertEquals( "Default parameter was not set correctly on Trans", DEFAULT_PARAM_VALUE, trans.getParameterDefault( TEST_PARAM_NAME ) ); assertEquals( "Parameter value should be blank in Trans", "", trans.getParameterValue( TEST_PARAM_NAME ) ); NamedParams params = new NamedParamsDefault(); params.addParameterDefinition( TEST_PARAM_NAME, NOT_DEFAULT_PARAM_VALUE, "This tests a non-default parameter" ); params.setParameterValue( TEST_PARAM_NAME, NOT_DEFAULT_PARAM_VALUE ); Pan.configureParameters( trans, params, transMeta ); assertEquals( "Parameter was not set correctly in Trans", NOT_DEFAULT_PARAM_VALUE, trans.getParameterValue( TEST_PARAM_NAME ) ); assertEquals( "Parameter was not set correctly in TransMeta", NOT_DEFAULT_PARAM_VALUE, transMeta.getParameterValue( TEST_PARAM_NAME ) ); }
### Question: CompressionPluginType extends BasePluginType implements PluginTypeInterface { public static CompressionPluginType getInstance() { if ( pluginType == null ) { pluginType = new CompressionPluginType(); } return pluginType; } private CompressionPluginType(); static CompressionPluginType getInstance(); @Override void handlePluginAnnotation( Class<?> clazz, Annotation annotation, List<String> libraries, boolean nativePluginType, URL pluginFolder ); String[] getNaturalCategoriesOrder(); }### Answer: @Test public void testGetInstance() { CompressionPluginType instance = CompressionPluginType.getInstance(); CompressionPluginType instance2 = CompressionPluginType.getInstance(); assertTrue( instance == instance2 ); assertNotNull( instance ); CompressionPluginType.pluginType = null; CompressionPluginType instance3 = CompressionPluginType.getInstance(); assertFalse( instance == instance3 ); }
### Question: NoneCompressionProvider implements CompressionProvider { @Override public String getName() { return "None"; } @Override CompressionInputStream createInputStream( InputStream in ); @Override boolean supportsInput(); @Override CompressionOutputStream createOutputStream( OutputStream out ); @Override boolean supportsOutput(); @Override String getDescription(); @Override String getName(); @Override String getDefaultExtension(); }### Answer: @Test public void testGetName() { NoneCompressionProvider provider = (NoneCompressionProvider) factory.getCompressionProviderByName( PROVIDER_NAME ); assertNotNull( provider ); assertEquals( PROVIDER_NAME, provider.getName() ); }
### Question: BaseCartePlugin extends BaseHttpServlet implements CartePluginInterface, CarteRequestHandler { @Deprecated @Override public void doGet( HttpServletRequest req, final HttpServletResponse resp ) throws IOException { service( req, resp ); } @Deprecated @Override void doGet( HttpServletRequest req, final HttpServletResponse resp ); @Override abstract void handleRequest( CarteRequest request ); @Override abstract String getContextPath(); String getService(); String toString(); }### Answer: @Test @SuppressWarnings( "deprecation" ) public void testDoGet() throws Exception { baseCartePlugin.doGet( req, resp ); verify( baseCartePlugin ).service( req, resp ); }
### Question: NoneCompressionProvider implements CompressionProvider { @Override public CompressionInputStream createInputStream( InputStream in ) throws IOException { return new NoneCompressionInputStream( in, this ); } @Override CompressionInputStream createInputStream( InputStream in ); @Override boolean supportsInput(); @Override CompressionOutputStream createOutputStream( OutputStream out ); @Override boolean supportsOutput(); @Override String getDescription(); @Override String getName(); @Override String getDefaultExtension(); }### Answer: @Test public void testCreateInputStream() throws IOException { NoneCompressionProvider provider = (NoneCompressionProvider) factory.getCompressionProviderByName( PROVIDER_NAME ); ByteArrayInputStream in = new ByteArrayInputStream( "Test".getBytes() ); NoneCompressionInputStream inStream = new NoneCompressionInputStream( in, provider ); assertNotNull( inStream ); NoneCompressionInputStream ncis = (NoneCompressionInputStream) provider.createInputStream( in ); assertNotNull( ncis ); }
### Question: NoneCompressionProvider implements CompressionProvider { @Override public CompressionOutputStream createOutputStream( OutputStream out ) throws IOException { return new NoneCompressionOutputStream( out, this ); } @Override CompressionInputStream createInputStream( InputStream in ); @Override boolean supportsInput(); @Override CompressionOutputStream createOutputStream( OutputStream out ); @Override boolean supportsOutput(); @Override String getDescription(); @Override String getName(); @Override String getDefaultExtension(); }### Answer: @Test public void testCreateOutputStream() throws IOException { NoneCompressionProvider provider = (NoneCompressionProvider) factory.getCompressionProviderByName( PROVIDER_NAME ); ByteArrayOutputStream out = new ByteArrayOutputStream(); NoneCompressionOutputStream outStream = new NoneCompressionOutputStream( out, provider ); assertNotNull( outStream ); NoneCompressionOutputStream ncis = (NoneCompressionOutputStream) provider.createOutputStream( out ); assertNotNull( ncis ); }
### Question: CompressionOutputStream extends OutputStream { public CompressionProvider getCompressionProvider() { return compressionProvider; } CompressionOutputStream( OutputStream out, CompressionProvider provider ); private CompressionOutputStream(); CompressionProvider getCompressionProvider(); void addEntry( String filename, String extension ); @Override void close(); @Override void write( int b ); @Override void write( byte[] b ); @Override void write( byte[] b, int off, int len ); }### Answer: @Test public void getCompressionProvider() { CompressionProvider provider = outStream.getCompressionProvider(); assertEquals( provider.getName(), PROVIDER_NAME ); }
### Question: CompressionOutputStream extends OutputStream { @Override public void close() throws IOException { delegate.close(); } CompressionOutputStream( OutputStream out, CompressionProvider provider ); private CompressionOutputStream(); CompressionProvider getCompressionProvider(); void addEntry( String filename, String extension ); @Override void close(); @Override void write( int b ); @Override void write( byte[] b ); @Override void write( byte[] b, int off, int len ); }### Answer: @Test public void testClose() throws IOException { CompressionProvider provider = outStream.getCompressionProvider(); ByteArrayOutputStream out = new ByteArrayOutputStream(); outStream = new DummyCompressionOS( out, provider ); outStream.close(); }
### Question: CompressionOutputStream extends OutputStream { @Override public void write( int b ) throws IOException { delegate.write( b ); } CompressionOutputStream( OutputStream out, CompressionProvider provider ); private CompressionOutputStream(); CompressionProvider getCompressionProvider(); void addEntry( String filename, String extension ); @Override void close(); @Override void write( int b ); @Override void write( byte[] b ); @Override void write( byte[] b, int off, int len ); }### Answer: @Test public void testWrite() throws IOException { CompressionProvider provider = outStream.getCompressionProvider(); ByteArrayOutputStream out = new ByteArrayOutputStream(); outStream = new DummyCompressionOS( out, provider ); outStream.write( "Test".getBytes() ); }
### Question: CompressionOutputStream extends OutputStream { public void addEntry( String filename, String extension ) throws IOException { } CompressionOutputStream( OutputStream out, CompressionProvider provider ); private CompressionOutputStream(); CompressionProvider getCompressionProvider(); void addEntry( String filename, String extension ); @Override void close(); @Override void write( int b ); @Override void write( byte[] b ); @Override void write( byte[] b, int off, int len ); }### Answer: @Test public void testAddEntry() throws IOException { CompressionProvider provider = outStream.getCompressionProvider(); ByteArrayOutputStream out = new ByteArrayOutputStream(); outStream = new DummyCompressionOS( out, provider ); outStream.addEntry( null, null ); }
### Question: CompressionProviderFactory implements CompressionProviderFactoryInterface { public static CompressionProviderFactory getInstance() { return INSTANCE; } private CompressionProviderFactory(); static CompressionProviderFactory getInstance(); @Override CompressionProvider createCompressionProviderInstance( String name ); @Override Collection<CompressionProvider> getCompressionProviders(); @Override String[] getCompressionProviderNames(); @Override CompressionProvider getCompressionProviderByName( String name ); }### Answer: @Test public void testGetInstance() { assertNotNull( factory ); }
### Question: CompressionProviderFactory implements CompressionProviderFactoryInterface { @Override public String[] getCompressionProviderNames() { ArrayList<String> providerNames = new ArrayList<String>(); List<PluginInterface> providers = getPlugins(); if ( providers != null ) { for ( PluginInterface plugin : providers ) { try { CompressionProvider provider = PluginRegistry.getInstance().loadClass( plugin, CompressionProvider.class ); if ( provider != null ) { providerNames.add( provider.getName() ); } } catch ( Exception e ) { } } } return providerNames.toArray( new String[providerNames.size()] ); } private CompressionProviderFactory(); static CompressionProviderFactory getInstance(); @Override CompressionProvider createCompressionProviderInstance( String name ); @Override Collection<CompressionProvider> getCompressionProviders(); @Override String[] getCompressionProviderNames(); @Override CompressionProvider getCompressionProviderByName( String name ); }### Answer: @Test public void getCoreProviderNames() { @SuppressWarnings( "serial" ) final HashMap<String, Boolean> foundProvider = new HashMap<String, Boolean>() { { put( "None", false ); put( "Zip", false ); put( "GZip", false ); put( "Snappy", false ); put( "Hadoop-snappy", false ); } }; String[] providers = factory.getCompressionProviderNames(); assertNotNull( providers ); for ( String provider : providers ) { assertNotNull( foundProvider.get( provider ) ); foundProvider.put( provider, true ); } boolean foundAllProviders = true; for ( Boolean b : foundProvider.values() ) { foundAllProviders = foundAllProviders && b; } assertTrue( foundAllProviders ); }
### Question: CompressionProviderFactory implements CompressionProviderFactoryInterface { @Override public Collection<CompressionProvider> getCompressionProviders() { Collection<CompressionProvider> providerClasses = new ArrayList<CompressionProvider>(); List<PluginInterface> providers = getPlugins(); if ( providers != null ) { for ( PluginInterface plugin : providers ) { try { providerClasses.add( PluginRegistry.getInstance().loadClass( plugin, CompressionProvider.class ) ); } catch ( Exception e ) { } } } return providerClasses; } private CompressionProviderFactory(); static CompressionProviderFactory getInstance(); @Override CompressionProvider createCompressionProviderInstance( String name ); @Override Collection<CompressionProvider> getCompressionProviders(); @Override String[] getCompressionProviderNames(); @Override CompressionProvider getCompressionProviderByName( String name ); }### Answer: @Test public void getCoreProviders() { @SuppressWarnings( "serial" ) final HashMap<String, Boolean> foundProvider = new HashMap<String, Boolean>() { { put( "None", false ); put( "Zip", false ); put( "GZip", false ); put( "Snappy", false ); put( "Hadoop-snappy", false ); } }; Collection<CompressionProvider> providers = factory.getCompressionProviders(); assertNotNull( providers ); for ( CompressionProvider provider : providers ) { assertNotNull( foundProvider.get( provider.getName() ) ); foundProvider.put( provider.getName(), true ); } boolean foundAllProviders = true; for ( Boolean b : foundProvider.values() ) { foundAllProviders = foundAllProviders && b; } assertTrue( foundAllProviders ); }
### Question: BaseCartePlugin extends BaseHttpServlet implements CartePluginInterface, CarteRequestHandler { @Override protected void service( HttpServletRequest req, HttpServletResponse resp ) throws IOException { if ( isJettyMode() && !req.getContextPath().endsWith( getContextPath() ) ) { return; } if ( log.isDebug() ) { logDebug( getService() ); } handleRequest( new CarteRequestImpl( req, resp ) ); } @Deprecated @Override void doGet( HttpServletRequest req, final HttpServletResponse resp ); @Override abstract void handleRequest( CarteRequest request ); @Override abstract String getContextPath(); String getService(); String toString(); }### Answer: @Test public void testService() throws Exception { when( req.getContextPath() ).thenReturn( "/Path" ); when( baseCartePlugin.getContextPath() ).thenReturn( "/Path" ); when( log.isDebug() ).thenReturn( true ); baseCartePlugin.service( req, resp ); verify( log ).logDebug( baseCartePlugin.getService() ); verify( baseCartePlugin ).handleRequest( carteReqCaptor.capture() ); CarteRequestHandler.CarteRequest carteRequest = carteReqCaptor.getValue(); testCarteRequest( carteRequest ); testCarteResponse( carteRequest.respond( 200 ) ); }
### Question: CompressionInputStream extends InputStream { public CompressionProvider getCompressionProvider() { return compressionProvider; } CompressionInputStream( InputStream in, CompressionProvider provider ); private CompressionInputStream(); CompressionProvider getCompressionProvider(); Object nextEntry(); @Override void close(); @Override int read(); @Override int read( byte[] b ); @Override int read( byte[] b, int off, int len ); }### Answer: @Test public void getCompressionProvider() { CompressionProvider provider = inStream.getCompressionProvider(); assertEquals( provider.getName(), PROVIDER_NAME ); }
### Question: CompressionInputStream extends InputStream { public Object nextEntry() throws IOException { return null; } CompressionInputStream( InputStream in, CompressionProvider provider ); private CompressionInputStream(); CompressionProvider getCompressionProvider(); Object nextEntry(); @Override void close(); @Override int read(); @Override int read( byte[] b ); @Override int read( byte[] b, int off, int len ); }### Answer: @Test public void testNextEntry() throws IOException { assertNull( inStream.nextEntry() ); }
### Question: CompressionInputStream extends InputStream { @Override public void close() throws IOException { delegate.close(); } CompressionInputStream( InputStream in, CompressionProvider provider ); private CompressionInputStream(); CompressionProvider getCompressionProvider(); Object nextEntry(); @Override void close(); @Override int read(); @Override int read( byte[] b ); @Override int read( byte[] b, int off, int len ); }### Answer: @Test public void testClose() throws IOException { CompressionProvider provider = inStream.getCompressionProvider(); ByteArrayInputStream in = createTestInputStream(); inStream = new DummyCompressionIS( in, provider ); inStream.close(); }
### Question: CompressionInputStream extends InputStream { @Override public int read() throws IOException { return delegate.read(); } CompressionInputStream( InputStream in, CompressionProvider provider ); private CompressionInputStream(); CompressionProvider getCompressionProvider(); Object nextEntry(); @Override void close(); @Override int read(); @Override int read( byte[] b ); @Override int read( byte[] b, int off, int len ); }### Answer: @Test public void testRead() throws IOException { CompressionProvider provider = inStream.getCompressionProvider(); ByteArrayInputStream in = createTestInputStream(); inStream = new DummyCompressionIS( in, provider ); assertEquals( inStream.available(), inStream.read( new byte[ 100 ], 0, inStream.available() ) ); }
### Question: GZIPCompressionProvider implements CompressionProvider { @Override public String getName() { return "GZip"; } @Override GZIPCompressionInputStream createInputStream( InputStream in ); @Override boolean supportsInput(); @Override GZIPCompressionOutputStream createOutputStream( OutputStream out ); @Override boolean supportsOutput(); @Override String getDescription(); @Override String getName(); @Override String getDefaultExtension(); }### Answer: @Test public void testGetName() { GZIPCompressionProvider provider = (GZIPCompressionProvider) factory.getCompressionProviderByName( PROVIDER_NAME ); assertNotNull( provider ); assertEquals( PROVIDER_NAME, provider.getName() ); }
### Question: GZIPCompressionProvider implements CompressionProvider { @Override public GZIPCompressionInputStream createInputStream( InputStream in ) throws IOException { return new GZIPCompressionInputStream( in, this ); } @Override GZIPCompressionInputStream createInputStream( InputStream in ); @Override boolean supportsInput(); @Override GZIPCompressionOutputStream createOutputStream( OutputStream out ); @Override boolean supportsOutput(); @Override String getDescription(); @Override String getName(); @Override String getDefaultExtension(); }### Answer: @Test public void testCreateInputStream() throws IOException { GZIPCompressionProvider provider = (GZIPCompressionProvider) factory.getCompressionProviderByName( PROVIDER_NAME ); ByteArrayOutputStream baos = new ByteArrayOutputStream(); GZIPOutputStream gos = new GZIPOutputStream( baos ); byte[] testBytes = "Test".getBytes(); gos.write( testBytes ); ByteArrayInputStream in = new ByteArrayInputStream( baos.toByteArray() ); GZIPInputStream gis = new GZIPInputStream( in ); in = new ByteArrayInputStream( baos.toByteArray() ); GZIPCompressionInputStream ncis = provider.createInputStream( in ); assertNotNull( ncis ); GZIPCompressionInputStream ncis2 = provider.createInputStream( gis ); assertNotNull( ncis2 ); }
### Question: GZIPCompressionProvider implements CompressionProvider { @Override public GZIPCompressionOutputStream createOutputStream( OutputStream out ) throws IOException { return new GZIPCompressionOutputStream( out, this ); } @Override GZIPCompressionInputStream createInputStream( InputStream in ); @Override boolean supportsInput(); @Override GZIPCompressionOutputStream createOutputStream( OutputStream out ); @Override boolean supportsOutput(); @Override String getDescription(); @Override String getName(); @Override String getDefaultExtension(); }### Answer: @Test public void testCreateOutputStream() throws IOException { GZIPCompressionProvider provider = (GZIPCompressionProvider) factory.getCompressionProviderByName( PROVIDER_NAME ); ByteArrayOutputStream out = new ByteArrayOutputStream(); GZIPOutputStream gos = new GZIPOutputStream( out ); GZIPCompressionOutputStream outStream = new GZIPCompressionOutputStream( out, provider ); assertNotNull( outStream ); out = new ByteArrayOutputStream(); GZIPCompressionOutputStream ncis = provider.createOutputStream( out ); assertNotNull( ncis ); GZIPCompressionOutputStream ncis2 = provider.createOutputStream( gos ); assertNotNull( ncis2 ); }
### Question: GZIPCompressionInputStream extends CompressionInputStream { @Override public void close() throws IOException { GZIPInputStream gis = (GZIPInputStream) delegate; gis.close(); } GZIPCompressionInputStream( InputStream in, CompressionProvider provider ); @Override void close(); @Override int read(); }### Answer: @Test public void testClose() throws IOException { inStream = new GZIPCompressionInputStream( createGZIPInputStream(), provider ) { }; inStream.close(); }
### Question: GZIPCompressionInputStream extends CompressionInputStream { @Override public int read() throws IOException { GZIPInputStream gis = (GZIPInputStream) delegate; return gis.read(); } GZIPCompressionInputStream( InputStream in, CompressionProvider provider ); @Override void close(); @Override int read(); }### Answer: @Test public void testRead() throws IOException { inStream = new GZIPCompressionInputStream( createGZIPInputStream(), provider ) { }; inStream.read( new byte[100], 0, inStream.available() ); }
### Question: GZIPCompressionOutputStream extends CompressionOutputStream { @Override public void close() throws IOException { GZIPOutputStream zos = (GZIPOutputStream) delegate; zos.close(); } GZIPCompressionOutputStream( OutputStream out, CompressionProvider provider ); @Override void close(); }### Answer: @Test public void testClose() throws IOException { CompressionProvider provider = outStream.getCompressionProvider(); ByteArrayOutputStream out = new ByteArrayOutputStream(); outStream = new GZIPCompressionOutputStream( out, provider ) { }; outStream.close(); try { outStream.write( "This will throw an Exception if the stream is already closed".getBytes() ); fail(); } catch ( IOException e ) { } }
### Question: BaseCartePlugin extends BaseHttpServlet implements CartePluginInterface, CarteRequestHandler { public String getService() { return getContextPath() + " (" + toString() + ")"; } @Deprecated @Override void doGet( HttpServletRequest req, final HttpServletResponse resp ); @Override abstract void handleRequest( CarteRequest request ); @Override abstract String getContextPath(); String getService(); String toString(); }### Answer: @Test public void testGetService() throws Exception { when( baseCartePlugin.getContextPath() ) .thenReturn( "/Path" ); assertThat( baseCartePlugin.getService().startsWith( "/Path" ), is( true ) ); }
### Question: ZIPCompressionInputStream extends CompressionInputStream { @Override public Object nextEntry() throws IOException { ZipInputStream zis = (ZipInputStream) delegate; if ( zis == null ) { throw new IOException( "Not a valid input stream!" ); } return zis.getNextEntry(); } ZIPCompressionInputStream( InputStream in, CompressionProvider provider ); @Override void close(); @Override int read(); @Override Object nextEntry(); }### Answer: @Test public void testNextEntry() throws IOException { assertNotNull( createZIPInputStream().getNextEntry() ); }
### Question: ZIPCompressionInputStream extends CompressionInputStream { @Override public void close() throws IOException { ZipInputStream zis = (ZipInputStream) delegate; if ( zis == null ) { throw new IOException( "Not a valid input stream!" ); } zis.close(); } ZIPCompressionInputStream( InputStream in, CompressionProvider provider ); @Override void close(); @Override int read(); @Override Object nextEntry(); }### Answer: @Test public void testClose() throws IOException { createZIPInputStream().close(); }
### Question: ZIPCompressionInputStream extends CompressionInputStream { @Override public int read() throws IOException { ZipInputStream zis = (ZipInputStream) delegate; if ( zis == null ) { throw new IOException( "Not a valid input stream!" ); } return zis.read(); } ZIPCompressionInputStream( InputStream in, CompressionProvider provider ); @Override void close(); @Override int read(); @Override Object nextEntry(); }### Answer: @Test public void testRead() throws IOException { CompressionProvider provider = inStream.getCompressionProvider(); ByteArrayInputStream in = new ByteArrayInputStream( "Test".getBytes() ); inStream = new ZIPCompressionInputStream( in, provider ) { }; inStream.read( new byte[100], 0, inStream.available() ); }
### Question: ZIPCompressionProvider implements CompressionProvider { @Override public String getName() { return "Zip"; } @Override ZIPCompressionInputStream createInputStream( InputStream in ); @Override boolean supportsInput(); @Override ZIPCompressionOutputStream createOutputStream( OutputStream out ); @Override boolean supportsOutput(); @Override String getDescription(); @Override String getName(); @Override String getDefaultExtension(); }### Answer: @Test public void testGetName() { ZIPCompressionProvider provider = (ZIPCompressionProvider) factory.getCompressionProviderByName( PROVIDER_NAME ); assertNotNull( provider ); assertEquals( PROVIDER_NAME, provider.getName() ); }
### Question: ZIPCompressionProvider implements CompressionProvider { @Override public ZIPCompressionInputStream createInputStream( InputStream in ) throws IOException { return new ZIPCompressionInputStream( in, this ); } @Override ZIPCompressionInputStream createInputStream( InputStream in ); @Override boolean supportsInput(); @Override ZIPCompressionOutputStream createOutputStream( OutputStream out ); @Override boolean supportsOutput(); @Override String getDescription(); @Override String getName(); @Override String getDefaultExtension(); }### Answer: @Test public void testCreateInputStream() throws IOException { ZIPCompressionProvider provider = (ZIPCompressionProvider) factory.getCompressionProviderByName( PROVIDER_NAME ); ByteArrayInputStream in = new ByteArrayInputStream( "Test".getBytes() ); ZipInputStream zis = new ZipInputStream( in ); ZIPCompressionInputStream inStream = new ZIPCompressionInputStream( in, provider ); assertNotNull( inStream ); ZIPCompressionInputStream ncis = provider.createInputStream( in ); assertNotNull( ncis ); ZIPCompressionInputStream ncis2 = provider.createInputStream( zis ); assertNotNull( ncis2 ); }
### Question: ZIPCompressionProvider implements CompressionProvider { @Override public ZIPCompressionOutputStream createOutputStream( OutputStream out ) throws IOException { return new ZIPCompressionOutputStream( out, this ); } @Override ZIPCompressionInputStream createInputStream( InputStream in ); @Override boolean supportsInput(); @Override ZIPCompressionOutputStream createOutputStream( OutputStream out ); @Override boolean supportsOutput(); @Override String getDescription(); @Override String getName(); @Override String getDefaultExtension(); }### Answer: @Test public void testCreateOutputStream() throws IOException { ZIPCompressionProvider provider = (ZIPCompressionProvider) factory.getCompressionProviderByName( PROVIDER_NAME ); ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zos = new ZipOutputStream( out ); ZIPCompressionOutputStream outStream = new ZIPCompressionOutputStream( out, provider ); assertNotNull( outStream ); ZIPCompressionOutputStream ncis = provider.createOutputStream( out ); assertNotNull( ncis ); ZIPCompressionOutputStream ncis2 = provider.createOutputStream( zos ); assertNotNull( ncis2 ); }
### Question: ZIPCompressionOutputStream extends CompressionOutputStream { @Override public void close() throws IOException { ZipOutputStream zos = (ZipOutputStream) delegate; zos.flush(); zos.closeEntry(); zos.finish(); zos.close(); } ZIPCompressionOutputStream( OutputStream out, CompressionProvider provider ); @Override void close(); @Override void addEntry( String filename, String extension ); }### Answer: @Test public void testClose() throws IOException { CompressionProvider provider = outStream.getCompressionProvider(); ByteArrayOutputStream out = new ByteArrayOutputStream(); outStream = new ZIPCompressionOutputStream( out, provider ); outStream.close(); }
### Question: ZIPCompressionOutputStream extends CompressionOutputStream { @Override public void addEntry( String filename, String extension ) throws IOException { int index = filename.lastIndexOf( Const.FILE_SEPARATOR ); String entryPath; if ( index != -1 ) { entryPath = filename.substring( index + 1 ); } else { entryPath = filename; } index = entryPath.toLowerCase().lastIndexOf( ".zip" ); if ( index != -1 ) { entryPath = entryPath.substring( 0, index ) + entryPath.substring( index + ".zip".length() ); } if ( !Utils.isEmpty( extension ) ) { entryPath += "." + extension; } ZipEntry zipentry = new ZipEntry( entryPath ); zipentry.setComment( "Compressed by Kettle" ); ( (ZipOutputStream) delegate ).putNextEntry( zipentry ); } ZIPCompressionOutputStream( OutputStream out, CompressionProvider provider ); @Override void close(); @Override void addEntry( String filename, String extension ); }### Answer: @Test public void testAddEntryAndWrite() throws IOException { CompressionProvider provider = outStream.getCompressionProvider(); ByteArrayOutputStream out = new ByteArrayOutputStream(); outStream = new ZIPCompressionOutputStream( out, provider ); outStream.addEntry( "./test.zip", null ); outStream.write( "Test".getBytes() ); }
### Question: SnappyCompressionProvider implements CompressionProvider { @Override public String getName() { return "Snappy"; } @Override SnappyCompressionInputStream createInputStream( InputStream in ); @Override boolean supportsInput(); @Override SnappyCompressionOutputStream createOutputStream( OutputStream out ); @Override boolean supportsOutput(); @Override String getDescription(); @Override String getName(); @Override String getDefaultExtension(); }### Answer: @Test public void testGetName() { SnappyCompressionProvider provider = (SnappyCompressionProvider) factory.getCompressionProviderByName( PROVIDER_NAME ); assertNotNull( provider ); assertEquals( PROVIDER_NAME, provider.getName() ); }
### Question: SnappyCompressionProvider implements CompressionProvider { @Override public SnappyCompressionInputStream createInputStream( InputStream in ) throws IOException { return new SnappyCompressionInputStream( in, this ); } @Override SnappyCompressionInputStream createInputStream( InputStream in ); @Override boolean supportsInput(); @Override SnappyCompressionOutputStream createOutputStream( OutputStream out ); @Override boolean supportsOutput(); @Override String getDescription(); @Override String getName(); @Override String getDefaultExtension(); }### Answer: @Test public void testCreateInputStream() throws IOException { SnappyCompressionProvider provider = (SnappyCompressionProvider) factory.getCompressionProviderByName( PROVIDER_NAME ); SnappyInputStream in = createSnappyInputStream(); SnappyCompressionInputStream inStream = new SnappyCompressionInputStream( in, provider ); assertNotNull( inStream ); SnappyCompressionInputStream ncis = provider.createInputStream( in ); assertNotNull( ncis ); }
### Question: SnappyCompressionProvider implements CompressionProvider { @Override public SnappyCompressionOutputStream createOutputStream( OutputStream out ) throws IOException { return new SnappyCompressionOutputStream( out, this ); } @Override SnappyCompressionInputStream createInputStream( InputStream in ); @Override boolean supportsInput(); @Override SnappyCompressionOutputStream createOutputStream( OutputStream out ); @Override boolean supportsOutput(); @Override String getDescription(); @Override String getName(); @Override String getDefaultExtension(); }### Answer: @Test public void testCreateOutputStream() throws IOException { SnappyCompressionProvider provider = (SnappyCompressionProvider) factory.getCompressionProviderByName( PROVIDER_NAME ); ByteArrayOutputStream out = new ByteArrayOutputStream(); SnappyCompressionOutputStream outStream = new SnappyCompressionOutputStream( out, provider ); assertNotNull( outStream ); SnappyCompressionOutputStream ncis = provider.createOutputStream( out ); assertNotNull( ncis ); }
### Question: SnappyCompressionInputStream extends CompressionInputStream { @Override public Object nextEntry() throws IOException { return null; } SnappyCompressionInputStream( InputStream in, CompressionProvider provider ); @Override void close(); @Override int read(); @Override Object nextEntry(); }### Answer: @Test public void testNextEntry() throws IOException { assertNull( inStream.nextEntry() ); }
### Question: SnappyCompressionInputStream extends CompressionInputStream { @Override public void close() throws IOException { ( (SnappyInputStream) delegate ).close(); } SnappyCompressionInputStream( InputStream in, CompressionProvider provider ); @Override void close(); @Override int read(); @Override Object nextEntry(); }### Answer: @Test public void testClose() throws IOException { inStream = new SnappyCompressionInputStream( createSnappyInputStream(), provider ); inStream.close(); }
### Question: SnappyCompressionInputStream extends CompressionInputStream { @Override public int read() throws IOException { return ( (SnappyInputStream) delegate ).read(); } SnappyCompressionInputStream( InputStream in, CompressionProvider provider ); @Override void close(); @Override int read(); @Override Object nextEntry(); }### Answer: @Test public void testRead() throws IOException { assertEquals( inStream.available(), inStream.read( new byte[100], 0, inStream.available() ) ); }
### Question: SnappyCompressionOutputStream extends CompressionOutputStream { @Override public void close() throws IOException { SnappyOutputStream zos = (SnappyOutputStream) delegate; zos.flush(); zos.close(); } SnappyCompressionOutputStream( OutputStream out, CompressionProvider provider ); @Override void close(); @Override void write( int b ); }### Answer: @Test public void testClose() throws IOException { CompressionProvider provider = outStream.getCompressionProvider(); ByteArrayOutputStream out = new ByteArrayOutputStream(); outStream = new SnappyCompressionOutputStream( out, provider ); outStream.close(); }
### Question: SnappyCompressionOutputStream extends CompressionOutputStream { @Override public void write( int b ) throws IOException { delegate.write( b ); } SnappyCompressionOutputStream( OutputStream out, CompressionProvider provider ); @Override void close(); @Override void write( int b ); }### Answer: @Test public void testWrite() throws IOException { CompressionProvider provider = outStream.getCompressionProvider(); ByteArrayOutputStream out = new ByteArrayOutputStream(); outStream = new SnappyCompressionOutputStream( out, provider ); outStream.write( "Test".getBytes() ); }
### Question: JavaScriptUtils { public static String jsToString( Object value, String classType ) { if ( classType.equalsIgnoreCase( "org.mozilla.javascript.NativeJavaObject" ) \|\| classType.equalsIgnoreCase( "org.mozilla.javascript.Undefined" ) ) { try { Value v = (Value) Context.jsToJava( value, Value.class ); return v.toString(); } catch ( Exception ev ) { return Context.toString( value ); } } else { return Context.toString( value ); } } static Object convertFromJs( Object value, int type, String fieldName ); static Number jsToNumber( Object value, String classType ); static Long jsToInteger( Object value, Class<?> clazz ); static String jsToString( Object value, String classType ); static Date jsToDate( Object value, String classType ); static BigDecimal jsToBigNumber( Object value, String classType ); }### Answer: @Test public void jsToString_Undefined() throws Exception { assertEquals( "null", JavaScriptUtils.jsToString( null, UNDEFINED ) ); } @Test public void jsToString_NativeJavaObject_Int() throws Exception { assertEquals( "1", JavaScriptUtils.jsToString( getIntValue(), JAVA_OBJECT ).trim() ); } @Test public void jsToString_NativeJavaObject_Double() throws Exception { assertEquals( "1.0", JavaScriptUtils.jsToString( getDoubleValue(), JAVA_OBJECT ).trim() ); } @Test public void jsToString_String() throws Exception { assertEquals( "qwerty", JavaScriptUtils.jsToString( "qwerty", String.class.getName() ) ); }
### Question: SerializationHelper { public static void readJobRep( Object object, Repository rep, ObjectId id_step, List<DatabaseMeta> databases ) throws KettleException { try { String jobXML = rep.getJobEntryAttributeString( id_step, "job-xml" ); ByteArrayInputStream bais = new ByteArrayInputStream( jobXML.getBytes() ); Document doc = XMLParserFactoryProducer.createSecureDocBuilderFactory().newDocumentBuilder().parse( bais ); read( object, doc.getDocumentElement() ); } catch ( ParserConfigurationException ex ) { throw new KettleException( ex.getMessage(), ex ); } catch ( SAXException ex ) { throw new KettleException( ex.getMessage(), ex ); } catch ( IOException ex ) { throw new KettleException( ex.getMessage(), ex ); } } static void read( Object object, Node node ); @SuppressWarnings( "unchecked" ) static void write( Object object, int indentLevel, StringBuilder buffer ); static void saveJobRep( Object object, Repository rep, ObjectId id_job, ObjectId id_job_entry ); static void readJobRep( Object object, Repository rep, ObjectId id_step, List<DatabaseMeta> databases ); static void saveStepRep( Object object, Repository rep, ObjectId id_transformation, ObjectId id_step ); static void readStepRep( Object object, Repository rep, ObjectId id_step, List<DatabaseMeta> databases ); }### Answer: @Test( expected = KettleException.class ) public void readingJobRepoThrowsExceptionWhenParsingXmlWithBigAmountOfExternalEntities() throws Exception { SerializationHelper.readJobRep( null, repo, null, new ArrayList<>() ); }
### Question: SerializationHelper { public static void readStepRep( Object object, Repository rep, ObjectId id_step, List<DatabaseMeta> databases ) throws KettleException { try { String stepXML = rep.getStepAttributeString( id_step, "step-xml" ); ByteArrayInputStream bais = new ByteArrayInputStream( stepXML.getBytes() ); Document doc = XMLParserFactoryProducer.createSecureDocBuilderFactory().newDocumentBuilder().parse( bais ); read( object, doc.getDocumentElement() ); } catch ( ParserConfigurationException ex ) { throw new KettleException( ex.getMessage(), ex ); } catch ( SAXException ex ) { throw new KettleException( ex.getMessage(), ex ); } catch ( IOException ex ) { throw new KettleException( ex.getMessage(), ex ); } } static void read( Object object, Node node ); @SuppressWarnings( "unchecked" ) static void write( Object object, int indentLevel, StringBuilder buffer ); static void saveJobRep( Object object, Repository rep, ObjectId id_job, ObjectId id_job_entry ); static void readJobRep( Object object, Repository rep, ObjectId id_step, List<DatabaseMeta> databases ); static void saveStepRep( Object object, Repository rep, ObjectId id_transformation, ObjectId id_step ); static void readStepRep( Object object, Repository rep, ObjectId id_step, List<DatabaseMeta> databases ); }### Answer: @Test( expected = KettleException.class ) public void readingStepRepoThrowsExceptionWhenParsingXmlWithBigAmountOfExternalEntities() throws Exception { SerializationHelper.readStepRep( null, repo, null, new ArrayList<>() ); }
### Question: StringSearchResult { public static final RowMetaInterface getResultRowMeta() { RowMetaInterface rowMeta = new RowMeta(); rowMeta.addValueMeta( new ValueMetaString( BaseMessages.getString( PKG, "SearchResult.TransOrJob" ) ) ); rowMeta.addValueMeta( new ValueMetaString( BaseMessages.getString( PKG, "SearchResult.StepDatabaseNotice" ) ) ); rowMeta.addValueMeta( new ValueMetaString( BaseMessages.getString( PKG, "SearchResult.String" ) ) ); rowMeta.addValueMeta( new ValueMetaString( BaseMessages.getString( PKG, "SearchResult.FieldName" ) ) ); return rowMeta; } StringSearchResult( String string, Object parentObject, Object grandParentObject, String fieldName ); Object getParentObject(); void setParentObject( Object parentObject ); String getString(); void setString( String string ); static final RowMetaInterface getResultRowMeta(); Object[] toRow(); String toString(); String getFieldName(); void setFieldName( String fieldName ); Object getGrandParentObject(); void setGrandParentObject( Object grandParentObject ); }### Answer: @Test public void testgetResultRowMeta() { RowMetaInterface rm = StringSearchResult.getResultRowMeta(); assertNotNull( rm ); assertEquals( 4, rm.getValueMetaList().size() ); assertEquals( ValueMetaInterface.TYPE_STRING, rm.getValueMeta( 0 ).getType() ); assertEquals( BaseMessages.getString( PKG, "SearchResult.TransOrJob" ), rm.getValueMeta( 0 ).getName() ); assertEquals( ValueMetaInterface.TYPE_STRING, rm.getValueMeta( 1 ).getType() ); assertEquals( BaseMessages.getString( PKG, "SearchResult.StepDatabaseNotice" ), rm.getValueMeta( 1 ).getName() ); assertEquals( ValueMetaInterface.TYPE_STRING, rm.getValueMeta( 2 ).getType() ); assertEquals( BaseMessages.getString( PKG, "SearchResult.String" ), rm.getValueMeta( 2 ).getName() ); assertEquals( ValueMetaInterface.TYPE_STRING, rm.getValueMeta( 3 ).getType() ); assertEquals( BaseMessages.getString( PKG, "SearchResult.FieldName" ), rm.getValueMeta( 3 ).getName() ); }
### Question: KettleLifecycleSupport { public void onEnvironmentInit() throws KettleException { if ( initialized.compareAndSet( false, true ) ) { for ( KettleLifecycleListener listener : kettleLifecycleListeners.keySet() ) { onEnvironmentInit( listener ); } } } KettleLifecycleSupport(); void onEnvironmentInit(); void onEnvironmentShutdown(); }### Answer: @Test public void testOnEnvironmentInit() throws Exception { final List<KettleLifecycleListener> listeners = new ArrayList<KettleLifecycleListener>(); listeners.add( createLifecycleListener() ); KettleLifecycleSupport kettleLifecycleSupport = new KettleLifecycleSupport(); assertNotNull( typeListenerRegistration.getValue() ); KettleLifecycleListener preInit = createLifecycleListener(); listeners.add( preInit ); doAnswer( new Answer() { @Override public Object answer( InvocationOnMock invocation ) throws Throwable { listeners.add( createLifecycleListener() ); return null; } } ).when( preInit ).onEnvironmentInit(); verifyNoMoreInteractions( listeners.toArray() ); kettleLifecycleSupport.onEnvironmentInit(); for ( KettleLifecycleListener listener : listeners ) { verify( listener ).onEnvironmentInit(); } verifyNoMoreInteractions( listeners.toArray() ); KettleLifecycleListener postInit = createLifecycleListener(); verify( postInit ).onEnvironmentInit(); verifyNoMoreInteractions( listeners.toArray() ); }
### Question: MissingEntry extends JobEntrySpecial { @Override public Result execute( Result previousResult, int nr ) throws KettleJobException { previousResult.setResult( false ); previousResult.setNrErrors( previousResult.getNrErrors() + 1 ); getLogChannel().logError( BaseMessages.getString( MissingEntry.class, "MissingEntry.Log.CannotRunJob" ) ); return previousResult; } MissingEntry(); MissingEntry( String name, String missingPluginId ); @Override Result execute( Result previousResult, int nr ); String getMissingPluginId(); }### Answer: @Test public void testExecute() throws KettleJobException { MissingEntry entry = spy( new MissingEntry() ); when( entry.getLogChannel() ).thenReturn( mock( LogChannel.class ) ); entry.setName( "MissingTest" ); Result result = new Result(); result.setNrErrors( 0 ); result.setResult( true ); entry.execute( result, 0 ); assertEquals( 1, result.getNrErrors() ); assertEquals( false, result.getResult() ); }
### Question: JobEntryDelay extends JobEntryBase implements Cloneable, JobEntryInterface { public String getRealMaximumTimeout() { return Const.trim( environmentSubstitute( getMaximumTimeout() ) ); } JobEntryDelay( String n ); JobEntryDelay(); @Override Object clone(); @Override String getXML(); @Override void loadXML( Node entrynode, List<DatabaseMeta> databases, List<SlaveServer> slaveServers, Repository rep, IMetaStore metaStore ); @Override void loadRep( Repository rep, IMetaStore metaStore, ObjectId id_jobentry, List<DatabaseMeta> databases, List<SlaveServer> slaveServers ); @Override void saveRep( Repository rep, IMetaStore metaStore, ObjectId id_job ); @Override Result execute( Result previousResult, int nr ); @Override boolean resetErrorsBeforeExecution(); @Override boolean evaluates(); @Override boolean isUnconditional(); String getMaximumTimeout(); String getRealMaximumTimeout(); @Deprecated String getrealMaximumTimeout(); void setMaximumTimeout( String s ); @Override void check( List<CheckResultInterface> remarks, JobMeta jobMeta, VariableSpace space, Repository repository, IMetaStore metaStore ); int getScaleTime(); void setScaleTime( int scaleTime ); public int scaleTime; }### Answer: @Test public void testGetRealMaximumTimeout() { JobEntryDelay entry = new JobEntryDelay(); assertTrue( Utils.isEmpty( entry.getRealMaximumTimeout() ) ); entry.setMaximumTimeout( " 1" ); assertEquals( "1", entry.getRealMaximumTimeout() ); entry.setVariable( "testValue", " 20" ); entry.setMaximumTimeout( "${testValue}" ); assertEquals( "20", entry.getRealMaximumTimeout() ); }
### Question: JobEntryJobRunner implements Runnable { public boolean isFinished() { return finished; } JobEntryJobRunner( Job job, Result result, int entryNr, LogChannelInterface log ); void run(); void setResult( Result result ); Result getResult(); LogChannelInterface getLog(); void setLog( LogChannelInterface log ); Job getJob(); void setJob( Job job ); int getEntryNr(); void setEntryNr( int entryNr ); boolean isFinished(); void waitUntilFinished(); }### Answer: @Test public void testIsFinished() throws Exception { assertFalse( jobRunner.isFinished() ); when( mockJob.isStopped() ).thenReturn( false ); when( mockJob.getParentJob() ).thenReturn( parentJob ); when( parentJob.isStopped() ).thenReturn( false ); when( mockJob.execute( Mockito.anyInt(), Mockito.any( Result.class ) ) ).thenReturn( mockResult ); jobRunner.run(); assertTrue( jobRunner.isFinished() ); }
### Question: JobEntryJobRunner implements Runnable { public void waitUntilFinished() { while ( !isFinished() && !job.isStopped() ) { try { Thread.sleep( 0, 1 ); } catch ( InterruptedException e ) { } } } JobEntryJobRunner( Job job, Result result, int entryNr, LogChannelInterface log ); void run(); void setResult( Result result ); Result getResult(); LogChannelInterface getLog(); void setLog( LogChannelInterface log ); Job getJob(); void setJob( Job job ); int getEntryNr(); void setEntryNr( int entryNr ); boolean isFinished(); void waitUntilFinished(); }### Answer: @Test public void testWaitUntilFinished() throws Exception { when( mockJob.isStopped() ).thenReturn( true ); when( mockJob.getParentJob() ).thenReturn( parentJob ); when( parentJob.isStopped() ).thenReturn( false ); when( mockJob.execute( Mockito.anyInt(), Mockito.any( Result.class ) ) ).thenReturn( mockResult ); jobRunner.waitUntilFinished(); }
### Question: Carte { public WebServer getWebServer() { return webServer; } Carte( final SlaveServerConfig config ); Carte( final SlaveServerConfig config, Boolean joinOverride ); static void main( String[] args ); static void runCarte( SlaveServerConfig config ); WebServer getWebServer(); void setWebServer( WebServer webServer ); SlaveServerConfig getConfig(); void setConfig( SlaveServerConfig config ); }### Answer: @Ignore @Test public void test() throws Exception { CountDownLatch latch = new CountDownLatch( 1 ); System.setProperty( Const.KETTLE_SLAVE_DETECTION_TIMER, "100" ); SlaveServer master = new SlaveServer(); master.setHostname( "127.0.0.1" ); master.setPort( "9000" ); master.setUsername( "cluster" ); master.setPassword( "cluster" ); master.setMaster( true ); SlaveServerConfig config = new SlaveServerConfig(); config.setSlaveServer( master ); Carte carte = new Carte( config ); SlaveServerDetection slaveServerDetection = mock( SlaveServerDetection.class ); carte.getWebServer().getDetections().add( slaveServerDetection ); SlaveServer slaveServer = mock( SlaveServer.class, RETURNS_MOCKS ); when( slaveServerDetection.getSlaveServer() ).thenReturn( slaveServer ); when( slaveServer.getStatus() ).thenAnswer( new Answer<SlaveServerStatus>() { @Override public SlaveServerStatus answer( InvocationOnMock invocation ) throws Throwable { SlaveServerDetection anotherDetection = mock( SlaveServerDetection.class ); carte.getWebServer().getDetections().add( anotherDetection ); latch.countDown(); return new SlaveServerStatus(); } } ); latch.await( 10, TimeUnit.SECONDS ); assertEquals( carte.getWebServer().getDetections().size(), 2 ); carte.getWebServer().stopServer(); }
### Question: EngineMetaUtils { public static boolean isJobOrTransformation( EngineMetaInterface engineMetaInterface ) { if ( engineMetaInterface == null \|\| engineMetaInterface.getRepositoryElementType() == null ) { return false; } RepositoryObjectType objectType = engineMetaInterface.getRepositoryElementType(); return RepositoryObjectType.TRANSFORMATION.equals( objectType ) \|\| RepositoryObjectType.JOB.equals( objectType ); } static boolean isJobOrTransformation( EngineMetaInterface engineMetaInterface ); }### Answer: @Test public void isJobOrTransformation_withJob() { JobMeta jobInstance = new JobMeta(); assertTrue( EngineMetaUtils.isJobOrTransformation( jobInstance ) ); } @Test public void isJobOrTransformation_withTransformation() { TransMeta transfromataionInstance = new TransMeta(); assertTrue( EngineMetaUtils.isJobOrTransformation( transfromataionInstance ) ); } @Test public void isJobOrTransformationReturnsFalse_withDatabase() { EngineMetaInterface testMetaInstance = mock( EngineMetaInterface.class ); when( testMetaInstance.getRepositoryElementType() ).thenReturn( RepositoryObjectType.DATABASE ); assertFalse( EngineMetaUtils.isJobOrTransformation( testMetaInstance ) ); }
### Question: EnvironmentUtils { public synchronized boolean isUnsupportedBrowserEnvironment() { if ( getEnvironmentName().contains( "linux" ) ) { return false; } final String userAgent = getUserAgent(); if ( userAgent == null ) { return true; } return checkUserAgent( MSIE_PATTERN.matcher( userAgent ), getSupportedVersion( "min.windows.browser.supported" ) ) \|\| checkUserAgent( SAFARI_PATTERN.matcher( userAgent ), getSupportedVersion( "min.mac.browser.supported" ) ); } static synchronized EnvironmentUtils getInstance( ); synchronized boolean isUnsupportedBrowserEnvironment(); synchronized boolean isWebkitUnavailable(); boolean isBrowserEnvironmentCheckDisabled(); synchronized String getBrowserName(); static final String UBUNTU_BROWSER; static final String MAC_BROWSER; static final String WINDOWS_BROWSER; }### Answer: @Test public void isUnSupportedBrowserEnvironmentTest( ) { EnvironmentUtilsMock mock = new EnvironmentUtilsMock( Case.UBUNTU_16 ); assertFalse( mock.getMockedInstance().isUnsupportedBrowserEnvironment() ); mock = new EnvironmentUtilsMock( Case.MAC_OS_X ); assertFalse( mock.getMockedInstance().isUnsupportedBrowserEnvironment() ); mock = new EnvironmentUtilsMock( Case.WINDOWS ); assertFalse( mock.getMockedInstance().isUnsupportedBrowserEnvironment() ); mock = new EnvironmentUtilsMock( Case.MACOS_X_WRONG ); assertTrue( mock.getMockedInstance().isUnsupportedBrowserEnvironment() ); mock = new EnvironmentUtilsMock( Case.WINDOWS_WRONG ); assertTrue( mock.getMockedInstance().isUnsupportedBrowserEnvironment() ); }
### Question: EnvironmentUtils { public synchronized boolean isWebkitUnavailable() { String path = getWebkitPath(); String osName = getEnvironmentName(); return ( ( path == null \|\| path.length() < 1 \|\| !path.contains( "webkit" ) ) && ( osName.contains( SUPPORTED_DISTRIBUTION_NAME + " " + getSupportedVersion( "max.ubuntu.os.distribution.supported" ) ) \|\| osName.contains( SUPPORTED_DISTRIBUTION_NAME + " " + getSupportedVersion( "min.ubuntu.os.distribution.supported" ) ) ) ); } static synchronized EnvironmentUtils getInstance( ); synchronized boolean isUnsupportedBrowserEnvironment(); synchronized boolean isWebkitUnavailable(); boolean isBrowserEnvironmentCheckDisabled(); synchronized String getBrowserName(); static final String UBUNTU_BROWSER; static final String MAC_BROWSER; static final String WINDOWS_BROWSER; }### Answer: @Test public void isWebkitUnavailableTest( ) { EnvironmentUtilsMock mock = new EnvironmentUtilsMock( Case.UBUNTU_16 ); assertFalse( mock.getMockedInstance().isWebkitUnavailable() ); mock = new EnvironmentUtilsMock( Case.UBUNTU_14 ); assertFalse( mock.getMockedInstance().isWebkitUnavailable() ); mock = new EnvironmentUtilsMock( Case.MAC_OS_X ); assertFalse( mock.getMockedInstance().isWebkitUnavailable() ); mock = new EnvironmentUtilsMock( Case.WINDOWS ); assertFalse( mock.getMockedInstance().isWebkitUnavailable() ); mock = new EnvironmentUtilsMock( Case.UBUNTU_WRONG ); assertTrue( mock.getMockedInstance().isWebkitUnavailable() ); }
### Question: EnvironmentUtils { public synchronized String getBrowserName() { final String userAgent = getUserAgent(); if ( userAgent == null ) { return ""; } if ( userAgent.contains( WINDOWS_BROWSER ) ) { return WINDOWS_BROWSER; } else if ( userAgent.contains( UBUNTU_BROWSER ) ) { return UBUNTU_BROWSER; } else if ( userAgent.contains( MAC_BROWSER ) ) { return MAC_BROWSER; } return ""; } static synchronized EnvironmentUtils getInstance( ); synchronized boolean isUnsupportedBrowserEnvironment(); synchronized boolean isWebkitUnavailable(); boolean isBrowserEnvironmentCheckDisabled(); synchronized String getBrowserName(); static final String UBUNTU_BROWSER; static final String MAC_BROWSER; static final String WINDOWS_BROWSER; }### Answer: @Test public void getBrowserName( ) { EnvironmentUtilsMock mock = new EnvironmentUtilsMock( Case.UBUNTU_16 ); assertEquals( mock.getMockedInstance().getBrowserName(), "Midori" ); mock = new EnvironmentUtilsMock( Case.UBUNTU_14 ); assertEquals( mock.getMockedInstance().getBrowserName(), "Midori" ); mock = new EnvironmentUtilsMock( Case.MAC_OS_X ); assertEquals( mock.getMockedInstance().getBrowserName(), "Safari" ); mock = new EnvironmentUtilsMock( Case.MACOS_X_WRONG ); assertEquals( mock.getMockedInstance().getBrowserName(), "Safari" ); mock = new EnvironmentUtilsMock( Case.WINDOWS ); assertEquals( mock.getMockedInstance().getBrowserName(), "MSIE" ); mock = new EnvironmentUtilsMock( Case.WINDOWS_WRONG ); assertEquals( mock.getMockedInstance().getBrowserName(), "MSIE" ); }
### Question: DialogUtils { public static String getPathOf( RepositoryElementMetaInterface object ) { if ( object != null && !object.isDeleted() ) { RepositoryDirectoryInterface directory = object.getRepositoryDirectory(); if ( directory != null ) { String path = directory.getPath(); if ( path != null ) { if ( !path.endsWith( "/" ) ) { path += "/"; } path += object.getName(); return path; } } } return null; } static String getPathOf( RepositoryElementMetaInterface object ); static boolean objectWithTheSameNameExists( SharedObjectInterface object, Collection<? extends SharedObjectInterface> scope ); static String getPath( String parentPath, String path ); }### Answer: @Test public void nullObject() { assertNull( getPathOf( null ) ); } @Test public void deletedObject() { RepositoryElementMetaInterface object = mock( RepositoryElementMetaInterface.class ); when( object.isDeleted() ).thenReturn( true ); assertNull( getPathOf( object ) ); } @Test public void nullDirectory() { RepositoryElementMetaInterface object = mock( RepositoryElementMetaInterface.class ); when( object.getRepositoryDirectory() ).thenReturn( null ); assertNull( getPathOf( object ) ); } @Test public void nullDirectoryPath() { RepositoryElementMetaInterface object = mock( RepositoryElementMetaInterface.class ); RepositoryDirectoryInterface directory = mock( RepositoryDirectoryInterface.class ); when( object.getRepositoryDirectory() ).thenReturn( directory ); assertNull( getPathOf( object ) ); }
### Question: DialogUtils { public static boolean objectWithTheSameNameExists( SharedObjectInterface object, Collection<? extends SharedObjectInterface> scope ) { for ( SharedObjectInterface element : scope ) { String elementName = element.getName(); if ( elementName != null && elementName.equalsIgnoreCase( object.getName() ) && object != element ) { return true; } } return false; } static String getPathOf( RepositoryElementMetaInterface object ); static boolean objectWithTheSameNameExists( SharedObjectInterface object, Collection<? extends SharedObjectInterface> scope ); static String getPath( String parentPath, String path ); }### Answer: @Test public void objectWithTheSameNameExists_true_if_exists() { SharedObjectInterface sharedObject = mock( SharedObjectInterface.class ); when( sharedObject.getName() ).thenReturn( "TEST_OBJECT" ); assertTrue( objectWithTheSameNameExists( sharedObject, createTestScope( "TEST_OBJECT" ) ) ); } @Test public void objectWithTheSameNameExists_false_if_not_exist() { SharedObjectInterface sharedObject = mock( SharedObjectInterface.class ); when( sharedObject.getName() ).thenReturn( "NEW_TEST_OBJECT" ); assertFalse( objectWithTheSameNameExists( sharedObject, createTestScope( "TEST_OBJECT" ) ) ); } @Test public void objectWithTheSameNameExists_false_if_same_object() { SharedObjectInterface sharedObject = mock( SharedObjectInterface.class ); when( sharedObject.getName() ).thenReturn( "TEST_OBJECT" ); assertFalse( objectWithTheSameNameExists( sharedObject, Collections.singleton( sharedObject ) ) ); }
### Question: RepositoryExportSaxParser extends DefaultHandler2 { public void parse( RepositoryElementReadListener repositoryElementReadListener ) throws Exception { this.repositoryElementReadListener = repositoryElementReadListener; SAXParserFactory factory = XMLParserFactoryProducer.createSecureSAXParserFactory(); this.saxParser = factory.newSAXParser(); this.saxParser.parse( new File( filename ), this ); } RepositoryExportSaxParser( String filename, RepositoryImportFeedbackInterface feedback ); void parse( RepositoryElementReadListener repositoryElementReadListener ); void startElement( String uri, String localName, String qName, Attributes attributes ); void endElement( String uri, String localName, String qName ); void startCDATA(); void endCDATA(); void characters( char[] ch, int start, int length ); @Override void fatalError( SAXParseException e ); static final String STRING_REPOSITORY; static final String STRING_TRANSFORMATIONS; static final String STRING_TRANSFORMATION; static final String STRING_JOBS; static final String STRING_JOB; }### Answer: @Test public void testNoExceptionOccurs_WhenNameContainsJapaneseCharacters() throws Exception { repExpSAXParser = new RepositoryExportSaxParser( getRepositoryFile().getCanonicalPath(), repImpPgDlg ); try { repExpSAXParser.parse( repImpMock ); } catch ( Exception e ) { Assert.fail( "No exception is expected But occured: " + e ); } } @Test( expected = SAXParseException.class ) public void exceptionIsThrownWhenParsingXmlWithBigAmountOfExternalEntities() throws Exception { File file = createTmpFile( XXEUtils.MALICIOUS_XML ); repExpSAXParser = new RepositoryExportSaxParser( file.getAbsolutePath(), null ); repExpSAXParser.parse( repImpMock ); }
### Question: DialogUtils { public static String getPath( String parentPath, String path ) { if ( !parentPath.equals( "/" ) && path.startsWith( parentPath ) ) { path = path.replace( parentPath, "${" + Const.INTERNAL_VARIABLE_ENTRY_CURRENT_DIRECTORY + "}" ); } return path; } static String getPathOf( RepositoryElementMetaInterface object ); static boolean objectWithTheSameNameExists( SharedObjectInterface object, Collection<? extends SharedObjectInterface> scope ); static String getPath( String parentPath, String path ); }### Answer: @Test public void testGetPath() { String path = "/this/is/the/path/to/file"; String parentPath = "/this/is/the"; String newPath = DialogUtils.getPath( parentPath, path ); assertEquals( "${Internal.Entry.Current.Directory}/path/to/file", newPath ); }
### Question: AuthProviderController extends AbstractXulEventHandler { public void addProviders( List<NamedProvider> providers ) { if ( providers == null \|\| providers.isEmpty() ) { return; } for ( NamedProvider provider : providers ) { model.add( provider ); } model.setSelectedItem( model.getModelObjects().get( 0 ) ); } AuthProviderController(); void setBindingFactory( BindingFactory bf ); BindingFactory getBindingFactory(); void init(); void setResourceBundle( ResourceBundle res ); void open(); Collection<AuthProvider> getPossibleTypes(); void setNewOverlay( AuthProvider provider ); String getNewOverlay(); void onAccept(); void onCancel(); void addNew(); void remove(); void browse(); void addProviders( List<NamedProvider> providers ); }### Answer: @Test public void testAddProviders() { controller.addProviders( providers ); assertEquals( 8, controller.getModel().getModelObjects().size() ); }
### Question: AuthProviderController extends AbstractXulEventHandler { public void addNew() { NamedProvider provider = new NamedProvider( generateUniqueName(), new NoAuthAuthProvider( bf ) ); this.model.add( provider ); this.model.setSelectedItem( provider ); } AuthProviderController(); void setBindingFactory( BindingFactory bf ); BindingFactory getBindingFactory(); void init(); void setResourceBundle( ResourceBundle res ); void open(); Collection<AuthProvider> getPossibleTypes(); void setNewOverlay( AuthProvider provider ); String getNewOverlay(); void onAccept(); void onCancel(); void addNew(); void remove(); void browse(); void addProviders( List<NamedProvider> providers ); }### Answer: @Test public void testAddNew() { controller.addNew(); controller.addNew(); controller.addNew(); assertEquals( 3, controller.getModel().getModelObjects().size() ); }
### Question: AuthProviderController extends AbstractXulEventHandler { public void remove() { int index = this.model.getModelObjects().indexOf( this.model.getSelectedItem() ); if ( index >= 1 ) { index -= 1; } this.model.getModelObjects().remove( this.model.getSelectedItem() ); if ( !model.getModelObjects().isEmpty() ) { this.model.setSelectedItem( model.getModelObjects().get( index ) ); } else { this.model.setSelectedItem( null ); } } AuthProviderController(); void setBindingFactory( BindingFactory bf ); BindingFactory getBindingFactory(); void init(); void setResourceBundle( ResourceBundle res ); void open(); Collection<AuthProvider> getPossibleTypes(); void setNewOverlay( AuthProvider provider ); String getNewOverlay(); void onAccept(); void onCancel(); void addNew(); void remove(); void browse(); void addProviders( List<NamedProvider> providers ); }### Answer: @Test public void testRemove() { controller.addProviders( providers ); controller.getModel().setSelectedItem( controller.getModel().getModelObjects().get( 0 ) ); controller.remove(); assertEquals( 7, controller.getModel().getModelObjects().size() ); }
### Question: RepositoryCommonValidations { public static boolean checkUserInfo( IUser user ) { return !StringUtils.isBlank( user.getLogin() ) && !StringUtils.isBlank( user.getName() ); } static boolean checkUserInfo( IUser user ); static IUser normalizeUserInfo( IUser user ); }### Answer: @Test( expected = NullPointerException.class ) public void checkUserInfo_Null() { RepositoryCommonValidations.checkUserInfo( null ); } @Test public void checkUserInfo_LoginIsNull() { assertFalse( RepositoryCommonValidations.checkUserInfo( user( null, "name" ) ) ); } @Test public void checkUserInfo_LoginIsBlank() { assertFalse( RepositoryCommonValidations.checkUserInfo( user( "", "name" ) ) ); } @Test public void checkUserInfo_LoginContainsSpaces() { assertFalse( RepositoryCommonValidations.checkUserInfo( user( " \t\n ", "name" ) ) ); } @Test public void checkUserInfo_BothAreMeaningful() { assertTrue( RepositoryCommonValidations.checkUserInfo( user( "login", "name" ) ) ); }
### Question: SpoonPerspectiveManager { public void hidePerspective( final String perspectiveId ) { changePerspectiveVisibility( perspectiveId, true ); } @SuppressWarnings( "rawtypes" ) private SpoonPerspectiveManager(); String getStartupPerspective(); void setStartupPerspective( String startupPerspective ); static SpoonPerspectiveManager getInstance(); void setDeck( XulDeck deck ); void setXulDoc( XulDomContainer doc ); void addPerspective( SpoonPerspective perspective ); void showPerspective( final String perspectiveId ); void hidePerspective( final String perspectiveId ); @SuppressWarnings( "unchecked" ) List<SpoonPerspective> getPerspectives(); void activatePerspective( Class<? extends SpoonPerspective> clazz ); SpoonPerspective getActivePerspective(); boolean isForcePerspective(); void setForcePerspective( boolean forcePerspective ); void removePerspective( SpoonPerspective per ); void initialize(); }### Answer: @Test public void hidePerspective() { SpoonPerspectiveManager.PerspectiveManager perspectiveManager = perspectiveManagerMap.get( perspective ); spoonPerspectiveManager.hidePerspective( perspective.getId() ); verify( perspectiveManager ).setPerspectiveHidden( PERSPECTIVE_NAME, true ); }
### Question: SpoonPerspectiveManager { public void showPerspective( final String perspectiveId ) { changePerspectiveVisibility( perspectiveId, false ); } @SuppressWarnings( "rawtypes" ) private SpoonPerspectiveManager(); String getStartupPerspective(); void setStartupPerspective( String startupPerspective ); static SpoonPerspectiveManager getInstance(); void setDeck( XulDeck deck ); void setXulDoc( XulDomContainer doc ); void addPerspective( SpoonPerspective perspective ); void showPerspective( final String perspectiveId ); void hidePerspective( final String perspectiveId ); @SuppressWarnings( "unchecked" ) List<SpoonPerspective> getPerspectives(); void activatePerspective( Class<? extends SpoonPerspective> clazz ); SpoonPerspective getActivePerspective(); boolean isForcePerspective(); void setForcePerspective( boolean forcePerspective ); void removePerspective( SpoonPerspective per ); void initialize(); }### Answer: @Test public void showPerspective() { SpoonPerspectiveManager.PerspectiveManager perspectiveManager = perspectiveManagerMap.get( perspective ); spoonPerspectiveManager.showPerspective( perspective.getId() ); verify( perspectiveManager ).setPerspectiveHidden( PERSPECTIVE_NAME, false ); }
### Question: SpoonTransformationDelegate extends SpoonDelegate { boolean isLogTableDefined( TransLogTable logTable ) { return logTable.getDatabaseMeta() != null && !Utils.isEmpty( logTable.getTableName() ); } SpoonTransformationDelegate( Spoon spoon ); boolean addTransformation( TransMeta transMeta ); synchronized void closeTransformation( TransMeta transMeta ); Spoon getSpoon(); void addTransGraph( TransMeta transMeta ); void tabSelected( TabItem item ); List<TransMeta> getTransformationList(); TransMeta getTransformation( String name ); void removeTransformation( TransMeta transMeta ); TransMeta[] getLoadedTransformations(); TransGraph findTransGraphOfTransformation( TransMeta transMeta ); boolean isDefaultTransformationName( String name ); void undoTransformationAction( TransMeta transMeta, TransAction transAction ); void redoTransformationAction( TransMeta transMeta, TransAction transAction ); void executeTransformation( final TransMeta transMeta, final boolean local, final boolean remote, final boolean cluster, final boolean preview, final boolean debug, final Date replayDate, final boolean safe, LogLevel logLevel ); }### Answer: @Test public void testIsLogTableDefinedLogTableDefined() { DatabaseMeta databaseMeta = mock( DatabaseMeta.class ); doReturn( databaseMeta ).when( transLogTable ).getDatabaseMeta(); doReturn( "test_table" ).when( transLogTable ).getTableName(); assertTrue( delegate.isLogTableDefined( transLogTable ) ); } @Test public void testIsLogTableDefinedLogTableNotDefined() { DatabaseMeta databaseMeta = mock( DatabaseMeta.class ); doReturn( databaseMeta ).when( transLogTable ).getDatabaseMeta(); assertFalse( delegate.isLogTableDefined( transLogTable ) ); }
### Question: SpoonSharedObjectDelegate extends SpoonDelegate { protected static boolean isDuplicate( List<? extends SharedObjectInterface> objects, SharedObjectInterface object ) { String newName = object.getName(); for ( SharedObjectInterface soi : objects ) { if ( soi.getName().equalsIgnoreCase( newName ) ) { return true; } } return false; } SpoonSharedObjectDelegate( Spoon spoon ); void setSharedObjectSyncUtil( SharedObjectSyncUtil sharedObjectSyncUtil ); }### Answer: @Test public void isDuplicate_Same() { assertTrue( isDuplicate( singletonList( mockObject( "qwerty" ) ), mockObject( "qwerty" ) ) ); } @Test public void isDuplicate_DifferentCase() { assertTrue( isDuplicate( singletonList( mockObject( "qwerty" ) ), mockObject( "Qwerty" ) ) ); } @Test public void isDuplicate_NotSame() { assertFalse( isDuplicate( singletonList( mockObject( "qwerty" ) ), mockObject( "asdfg" ) ) ); }
### Question: PartitionSettings { public String[] getCodes() { return codes; } PartitionSettings( int exactSize, TransMeta transMeta, StepMeta stepMeta, PartitionSchemasProvider schemasProvider ); void fillOptionsAndCodesByPlugins( List<PluginInterface> plugins ); int getDefaultSelectedMethodIndex(); int getDefaultSelectedSchemaIndex(); String getMethodByMethodDescription( String methodDescription ); String[] getOptions(); String[] getCodes(); List<String> getSchemaNames(); String[] getSchemaNamesArray(); List<PartitionSchema> getSchemas(); StepMeta getStepMeta(); void updateMethodType( int methodType ); void updateMethod( String method ); void updateSchema( PartitionSchema schema ); void rollback( StepMeta before ); StepMeta getBefore(); StepMeta getAfter(); TransMeta getTransMeta(); }### Answer: @Test public void codesArePickedUpFromPlugins() { PartitionSettings settings = new PartitionSettings( StepPartitioningMeta.methodCodes.length, transMeta, stepMeta, partitionSchemasProvider ); assertTrue( Arrays.equals( StepPartitioningMeta.methodCodes, settings.getCodes() ) ); }
### Question: PartitionSettings { public void updateSchema( PartitionSchema schema ) { if ( schema != null && schema.getName() != null ) { stepMeta.getStepPartitioningMeta().setPartitionSchema( schema ); } } PartitionSettings( int exactSize, TransMeta transMeta, StepMeta stepMeta, PartitionSchemasProvider schemasProvider ); void fillOptionsAndCodesByPlugins( List<PluginInterface> plugins ); int getDefaultSelectedMethodIndex(); int getDefaultSelectedSchemaIndex(); String getMethodByMethodDescription( String methodDescription ); String[] getOptions(); String[] getCodes(); List<String> getSchemaNames(); String[] getSchemaNamesArray(); List<PartitionSchema> getSchemas(); StepMeta getStepMeta(); void updateMethodType( int methodType ); void updateMethod( String method ); void updateSchema( PartitionSchema schema ); void rollback( StepMeta before ); StepMeta getBefore(); StepMeta getAfter(); TransMeta getTransMeta(); }### Answer: @Test public void metaIsUpdated() { PartitionSchema schema = new PartitionSchema( "1", Collections.<String>emptyList() ); StepPartitioningMeta meta = mock( StepPartitioningMeta.class ); when( stepMeta.getStepPartitioningMeta() ).thenReturn( meta ); settings.updateSchema( schema ); verify( meta ).setPartitionSchema( schema ); } @Test public void metaIsNotUpdatedWithNull() { StepPartitioningMeta meta = mock( StepPartitioningMeta.class ); when( stepMeta.getStepPartitioningMeta() ).thenReturn( meta ); settings.updateSchema( null ); verify( meta, never() ).setPartitionSchema( any( PartitionSchema.class ) ); } @Test public void metaIsNotUpdatedWithNameless() { PartitionSchema schema = new PartitionSchema( null, Collections.<String>emptyList() ); StepPartitioningMeta meta = mock( StepPartitioningMeta.class ); when( stepMeta.getStepPartitioningMeta() ).thenReturn( meta ); settings.updateSchema( null ); verify( meta, never() ).setPartitionSchema( any( PartitionSchema.class ) ); }
### Question: ExpandedContentManager { public static boolean isVisible() { return isVisible( spoonInstance().getActiveTransGraph() ); } static boolean isVisible(); static boolean isVisible( TransGraph graph ); static void createExpandedContent( String url ); static void createExpandedContent( TransGraph parent, String url ); static void showExpandedContent(); static void showExpandedContent( TransGraph graph ); static Browser getExpandedContentForTransGraph( TransGraph graph ); static void hideExpandedContent(); static void closeExpandedContent(); static void hideExpandedContent( TransGraph graph ); static void closeExpandedContent( TransGraph graph ); }### Answer: @Test public void testIsBrowserVisibleTransGraph() { TransGraph transGraphMock = mock( TransGraph.class ); Control control1 = mock( Control.class ); Control control2 = mock( Control.class ); Browser browser = mock( Browser.class ); Control[] children = new Control[] { control1, control2, browser }; when( transGraphMock.getChildren() ).thenReturn( children ); Boolean result = ExpandedContentManager.isVisible( transGraphMock ); assertFalse( result ); children = new Control[] { browser, control1, control2 }; when( transGraphMock.getChildren() ).thenReturn( children ); result = ExpandedContentManager.isVisible( transGraphMock ); assertTrue( result ); }
### Question: ExpandedContentManager { public static void createExpandedContent( String url ) { createExpandedContent( spoonInstance().getActiveTransGraph(), url ); } static boolean isVisible(); static boolean isVisible( TransGraph graph ); static void createExpandedContent( String url ); static void createExpandedContent( TransGraph parent, String url ); static void showExpandedContent(); static void showExpandedContent( TransGraph graph ); static Browser getExpandedContentForTransGraph( TransGraph graph ); static void hideExpandedContent(); static void closeExpandedContent(); static void hideExpandedContent( TransGraph graph ); static void closeExpandedContent( TransGraph graph ); }### Answer: @Test public void testShowTransformationBrowserh() { TransGraph transGraphMock = mock( TransGraph.class ); Control control1 = mock( Control.class ); Control control2 = mock( Control.class ); Browser browser = mock( Browser.class ); SashForm sash = mock( SashForm.class ); when( sash.getWeights() ).thenReturn( new int[] { 277, 722 } ); Composite comp1 = mock( Composite.class ); Composite comp2 = mock( Composite.class ); Composite comp3 = mock( Composite.class ); Composite comp4 = mock( Composite.class ); when( browser.getParent() ).thenReturn( comp1 ); when( comp1.getParent() ).thenReturn( comp2 ); when( comp2.getParent() ).thenReturn( comp3 ); when( comp3.getParent() ).thenReturn( sash ); when( comp4.getParent() ).thenReturn( sash ); Control[] children = new Control[] { control1, control2, browser }; when( transGraphMock.getChildren() ).thenReturn( children ); ExpandedContentManager.createExpandedContent( transGraphMock, "" ); verify( browser ).setUrl( "" ); }
### Question: ExpandedContentManager { public static void hideExpandedContent() { hideExpandedContent( spoonInstance().getActiveTransGraph() ); } static boolean isVisible(); static boolean isVisible( TransGraph graph ); static void createExpandedContent( String url ); static void createExpandedContent( TransGraph parent, String url ); static void showExpandedContent(); static void showExpandedContent( TransGraph graph ); static Browser getExpandedContentForTransGraph( TransGraph graph ); static void hideExpandedContent(); static void closeExpandedContent(); static void hideExpandedContent( TransGraph graph ); static void closeExpandedContent( TransGraph graph ); }### Answer: @Test public void testHideExpandedContentManager() throws Exception { TransGraph transGraph = mock( TransGraph.class ); Browser browser = mock( Browser.class ); SashForm sashForm = mock( SashForm.class ); Composite parent = setupExpandedContentMocks( transGraph, browser, sashForm ); ExpandedContentManager.hideExpandedContent( transGraph ); verify( browser ).moveBelow( null ); verify( parent ).layout( true, true ); verify( parent ).redraw(); verify( sashForm ).setWeights( new int[] { 3, 2, 1 } ); }
### Question: ExpandedContentManager { public static void closeExpandedContent() { closeExpandedContent( spoonInstance().getActiveTransGraph() ); } static boolean isVisible(); static boolean isVisible( TransGraph graph ); static void createExpandedContent( String url ); static void createExpandedContent( TransGraph parent, String url ); static void showExpandedContent(); static void showExpandedContent( TransGraph graph ); static Browser getExpandedContentForTransGraph( TransGraph graph ); static void hideExpandedContent(); static void closeExpandedContent(); static void hideExpandedContent( TransGraph graph ); static void closeExpandedContent( TransGraph graph ); }### Answer: @Test public void testCloseExpandedContentManager() throws Exception { TransGraph transGraph = mock( TransGraph.class ); Browser browser = mock( Browser.class ); SashForm sashForm = mock( SashForm.class ); setupExpandedContentMocks( transGraph, browser, sashForm ); ExpandedContentManager.closeExpandedContent( transGraph ); verify( browser ).close(); verify( sashForm ).setWeights( new int[] { 3, 2, 1 } ); }
### Question: RepositoryCommonValidations { public static IUser normalizeUserInfo( IUser user ) { user.setLogin( user.getLogin().trim() ); user.setName( user.getName().trim() ); return user; } static boolean checkUserInfo( IUser user ); static IUser normalizeUserInfo( IUser user ); }### Answer: @Test( expected = NullPointerException.class ) public void normalizeUserInfo_Null() { RepositoryCommonValidations.normalizeUserInfo( null ); } @Test public void normalizeUserInfo_Valid() { IUser normalized = RepositoryCommonValidations.normalizeUserInfo( user( "login", "name" ) ); assertEquals( "login", normalized.getLogin() ); assertEquals( "login", normalized.getName() ); } @Test public void normalizeUserInfo_WithSpaces() { IUser normalized = RepositoryCommonValidations.normalizeUserInfo( user( " login \t\n ", "name" ) ); assertEquals( "login", normalized.getLogin() ); assertEquals( "login", normalized.getName() ); }
### Question: JobFileListener implements FileListener { public boolean accepts( String fileName ) { if ( fileName == null \|\| fileName.indexOf( '.' ) == -1 ) { return false; } String extension = fileName.substring( fileName.lastIndexOf( '.' ) + 1 ); return extension.equals( "kjb" ); } boolean open( Node jobNode, String fname, boolean importfile ); boolean save( EngineMetaInterface meta, String fname, boolean export ); void syncMetaName( EngineMetaInterface meta, String name ); boolean accepts( String fileName ); boolean acceptsXml( String nodeName ); String[] getFileTypeDisplayNames( Locale locale ); String[] getSupportedExtensions(); String getRootNodeName(); }### Answer: @Test public void testAccepts() throws Exception { assertFalse( jobFileListener.accepts( null ) ); assertFalse( jobFileListener.accepts( "NoDot" ) ); assertTrue( jobFileListener.accepts( "Job.kjb" ) ); assertTrue( jobFileListener.accepts( ".kjb" ) ); }
### Question: JobFileListener implements FileListener { public boolean acceptsXml( String nodeName ) { return "job".equals( nodeName ); } boolean open( Node jobNode, String fname, boolean importfile ); boolean save( EngineMetaInterface meta, String fname, boolean export ); void syncMetaName( EngineMetaInterface meta, String name ); boolean accepts( String fileName ); boolean acceptsXml( String nodeName ); String[] getFileTypeDisplayNames( Locale locale ); String[] getSupportedExtensions(); String getRootNodeName(); }### Answer: @Test public void testAcceptsXml() throws Exception { assertFalse( jobFileListener.acceptsXml( null ) ); assertFalse( jobFileListener.acceptsXml( "" ) ); assertFalse( jobFileListener.acceptsXml( "Job" ) ); assertTrue( jobFileListener.acceptsXml( "job" ) ); }
### Question: JobFileListener implements FileListener { public String[] getFileTypeDisplayNames( Locale locale ) { return new String[] { "Jobs", "XML" }; } boolean open( Node jobNode, String fname, boolean importfile ); boolean save( EngineMetaInterface meta, String fname, boolean export ); void syncMetaName( EngineMetaInterface meta, String name ); boolean accepts( String fileName ); boolean acceptsXml( String nodeName ); String[] getFileTypeDisplayNames( Locale locale ); String[] getSupportedExtensions(); String getRootNodeName(); }### Answer: @Test public void testGetFileTypeDisplayNames() throws Exception { String[] names = jobFileListener.getFileTypeDisplayNames( null ); assertNotNull( names ); assertEquals( 2, names.length ); assertEquals( "Jobs", names[0] ); assertEquals( "XML", names[1] ); }
### Question: JobFileListener implements FileListener { public String getRootNodeName() { return "job"; } boolean open( Node jobNode, String fname, boolean importfile ); boolean save( EngineMetaInterface meta, String fname, boolean export ); void syncMetaName( EngineMetaInterface meta, String name ); boolean accepts( String fileName ); boolean acceptsXml( String nodeName ); String[] getFileTypeDisplayNames( Locale locale ); String[] getSupportedExtensions(); String getRootNodeName(); }### Answer: @Test public void testGetRootNodeName() throws Exception { assertEquals( "job", jobFileListener.getRootNodeName() ); }
### Question: JobFileListener implements FileListener { public String[] getSupportedExtensions() { return new String[] { "kjb", "xml" }; } boolean open( Node jobNode, String fname, boolean importfile ); boolean save( EngineMetaInterface meta, String fname, boolean export ); void syncMetaName( EngineMetaInterface meta, String name ); boolean accepts( String fileName ); boolean acceptsXml( String nodeName ); String[] getFileTypeDisplayNames( Locale locale ); String[] getSupportedExtensions(); String getRootNodeName(); }### Answer: @Test public void testGetSupportedExtensions() throws Exception { String[] extensions = jobFileListener.getSupportedExtensions(); assertNotNull( extensions ); assertEquals( 2, extensions.length ); assertEquals( "kjb", extensions[0] ); assertEquals( "xml", extensions[1] ); }
### Question: SpoonPluginManager implements PluginTypeListener { @Override public void pluginAdded( final Object serviceObject ) { try { SpoonPluginInterface spoonPluginInterface = (SpoonPluginInterface) getPluginRegistry().loadClass( (PluginInterface) serviceObject ); if ( plugins.get( serviceObject ) != null ) { return; } SpoonPluginCategories categories = spoonPluginInterface.getClass().getAnnotation( SpoonPluginCategories.class ); if ( categories != null ) { for ( String cat : categories.value() ) { List<SpoonPluginInterface> categoryList = pluginCategoryMap.get( cat ); if ( categoryList == null ) { categoryList = new ArrayList<>(); pluginCategoryMap.put( cat, categoryList ); } categoryList.add( spoonPluginInterface ); } } if ( spoonPluginInterface.getPerspective() != null ) { getSpoonPerspectiveManager().addPerspective( spoonPluginInterface.getPerspective() ); } plugins.put( serviceObject, spoonPluginInterface ); } catch ( KettlePluginException e ) { e.printStackTrace(); } } private SpoonPluginManager(); @Override void pluginAdded( final Object serviceObject ); @Override void pluginRemoved( Object serviceObject ); @Override void pluginChanged( Object serviceObject ); static SpoonPluginManager getInstance(); void applyPluginsForContainer( final String category, final XulDomContainer container ); List<SpoonPluginInterface> getPlugins(); void notifyLifecycleListeners( SpoonLifecycleListener.SpoonLifeCycleEvent evt ); }### Answer: @Test public void testPluginAdded() throws Exception { spoonPluginManager.pluginAdded( plugin1 ); verify( spoonPerspectiveManager ).addPerspective( spoonPerspective ); assertEquals( 1, spoonPluginManager.getPlugins().size() ); assertSame( spoonPluginInterface1, spoonPluginManager.getPlugins().get( 0 ) ); }
### Question: SpoonPluginManager implements PluginTypeListener { @Override public void pluginRemoved( Object serviceObject ) { SpoonPluginInterface spoonPluginInterface = plugins.get( serviceObject ); if ( spoonPluginInterface == null ) { return; } SpoonPluginCategories categories = spoonPluginInterface.getClass().getAnnotation( SpoonPluginCategories.class ); if ( categories != null ) { for ( String cat : categories.value() ) { List<SpoonPluginInterface> categoryList = pluginCategoryMap.get( cat ); categoryList.remove( spoonPluginInterface ); } } if ( spoonPluginInterface.getPerspective() != null ) { getSpoonPerspectiveManager().removePerspective( spoonPluginInterface.getPerspective() ); } plugins.remove( serviceObject ); } private SpoonPluginManager(); @Override void pluginAdded( final Object serviceObject ); @Override void pluginRemoved( Object serviceObject ); @Override void pluginChanged( Object serviceObject ); static SpoonPluginManager getInstance(); void applyPluginsForContainer( final String category, final XulDomContainer container ); List<SpoonPluginInterface> getPlugins(); void notifyLifecycleListeners( SpoonLifecycleListener.SpoonLifeCycleEvent evt ); }### Answer: @Test public void testPluginRemoved() throws Exception { spoonPluginManager.pluginAdded( plugin1 ); spoonPluginManager.pluginRemoved( plugin1 ); verify( spoonPerspectiveManager ).removePerspective( spoonPerspective ); }
### Question: SpoonPluginManager implements PluginTypeListener { public void applyPluginsForContainer( final String category, final XulDomContainer container ) throws XulException { List<SpoonPluginInterface> plugins = pluginCategoryMap.get( category ); if ( plugins != null ) { for ( SpoonPluginInterface sp : plugins ) { sp.applyToContainer( category, container ); } } } private SpoonPluginManager(); @Override void pluginAdded( final Object serviceObject ); @Override void pluginRemoved( Object serviceObject ); @Override void pluginChanged( Object serviceObject ); static SpoonPluginManager getInstance(); void applyPluginsForContainer( final String category, final XulDomContainer container ); List<SpoonPluginInterface> getPlugins(); void notifyLifecycleListeners( SpoonLifecycleListener.SpoonLifeCycleEvent evt ); }### Answer: @Test public void testApplyPluginsForContainer() throws Exception { spoonPluginManager.pluginAdded( plugin1 ); spoonPluginManager.pluginAdded( plugin2 ); spoonPluginManager.applyPluginsForContainer( "trans-graph", xulDomContainer ); assertEquals( 2, applies.size() ); assertEquals( 1, (int) applies.get( spoonPluginInterface1 ) ); assertEquals( 1, (int) applies.get( spoonPluginInterface2 ) ); }
### Question: SpoonPluginManager implements PluginTypeListener { public List<SpoonPluginInterface> getPlugins() { return Collections.unmodifiableList( Arrays.asList( plugins.values().toArray( new SpoonPluginInterface[] {} ) ) ); } private SpoonPluginManager(); @Override void pluginAdded( final Object serviceObject ); @Override void pluginRemoved( Object serviceObject ); @Override void pluginChanged( Object serviceObject ); static SpoonPluginManager getInstance(); void applyPluginsForContainer( final String category, final XulDomContainer container ); List<SpoonPluginInterface> getPlugins(); void notifyLifecycleListeners( SpoonLifecycleListener.SpoonLifeCycleEvent evt ); }### Answer: @Test public void testGetPlugins() throws Exception { spoonPluginManager.pluginAdded( plugin1 ); spoonPluginManager.pluginAdded( plugin2 ); List<SpoonPluginInterface> pluginInterfaces = spoonPluginManager.getPlugins(); assertEquals( 2, pluginInterfaces.size() ); assertTrue( pluginInterfaces .containsAll( Arrays.asList( spoonPluginInterface1, spoonPluginInterface2 ) ) ); }
### Question: SpoonPluginManager implements PluginTypeListener { public void notifyLifecycleListeners( SpoonLifecycleListener.SpoonLifeCycleEvent evt ) { for ( SpoonPluginInterface p : plugins.values() ) { SpoonLifecycleListener listener = p.getLifecycleListener(); if ( listener != null ) { listener.onEvent( evt ); } } } private SpoonPluginManager(); @Override void pluginAdded( final Object serviceObject ); @Override void pluginRemoved( Object serviceObject ); @Override void pluginChanged( Object serviceObject ); static SpoonPluginManager getInstance(); void applyPluginsForContainer( final String category, final XulDomContainer container ); List<SpoonPluginInterface> getPlugins(); void notifyLifecycleListeners( SpoonLifecycleListener.SpoonLifeCycleEvent evt ); }### Answer: @Test public void testNotifyLifecycleListeners() throws Exception { spoonPluginManager.pluginAdded( plugin1 ); spoonPluginManager.pluginAdded( plugin2 ); spoonPluginManager.notifyLifecycleListeners( SpoonLifecycleListener.SpoonLifeCycleEvent.STARTUP ); assertEquals( 2, notifications.get() ); }
### Question: TransFileListener implements FileListener { public boolean accepts( String fileName ) { if ( fileName == null \|\| fileName.indexOf( '.' ) == -1 ) { return false; } String extension = fileName.substring( fileName.lastIndexOf( '.' ) + 1 ); return extension.equals( "ktr" ); } boolean open( Node transNode, String fname, boolean importfile ); boolean save( EngineMetaInterface meta, String fname, boolean export ); void syncMetaName( EngineMetaInterface meta, String name ); boolean accepts( String fileName ); boolean acceptsXml( String nodeName ); String[] getFileTypeDisplayNames( Locale locale ); String getRootNodeName(); String[] getSupportedExtensions(); }### Answer: @Test public void testAccepts() throws Exception { assertFalse( transFileListener.accepts( null ) ); assertFalse( transFileListener.accepts( "NoDot" ) ); assertTrue( transFileListener.accepts( "Trans.ktr" ) ); assertTrue( transFileListener.accepts( ".ktr" ) ); }
### Question: TransFileListener implements FileListener { public boolean acceptsXml( String nodeName ) { if ( "transformation".equals( nodeName ) ) { return true; } return false; } boolean open( Node transNode, String fname, boolean importfile ); boolean save( EngineMetaInterface meta, String fname, boolean export ); void syncMetaName( EngineMetaInterface meta, String name ); boolean accepts( String fileName ); boolean acceptsXml( String nodeName ); String[] getFileTypeDisplayNames( Locale locale ); String getRootNodeName(); String[] getSupportedExtensions(); }### Answer: @Test public void testAcceptsXml() throws Exception { assertFalse( transFileListener.acceptsXml( null ) ); assertFalse( transFileListener.acceptsXml( "" ) ); assertFalse( transFileListener.acceptsXml( "Transformation" ) ); assertTrue( transFileListener.acceptsXml( "transformation" ) ); }
### Question: TransFileListener implements FileListener { public String[] getFileTypeDisplayNames( Locale locale ) { return new String[]{ "Transformations", "XML" }; } boolean open( Node transNode, String fname, boolean importfile ); boolean save( EngineMetaInterface meta, String fname, boolean export ); void syncMetaName( EngineMetaInterface meta, String name ); boolean accepts( String fileName ); boolean acceptsXml( String nodeName ); String[] getFileTypeDisplayNames( Locale locale ); String getRootNodeName(); String[] getSupportedExtensions(); }### Answer: @Test public void testGetFileTypeDisplayNames() throws Exception { String[] names = transFileListener.getFileTypeDisplayNames( null ); assertNotNull( names ); assertEquals( 2, names.length ); assertEquals( "Transformations", names[0] ); assertEquals( "XML", names[1] ); }

Subsets and Splits

No saved queries yet

Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.