Datasets:

Minata
/

1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 269k rows

method2testcases stringlengths 118 6.63k
### Question: DetectLastRowMeta extends BaseStepMeta implements StepMetaInterface { public StepDataInterface getStepData() { return new DetectLastRowData(); } String getResultFieldName(); void setResultFieldName( String resultfieldname ); void loadXML( Node stepnode, List<DatabaseMeta> databases, IMetaStore metaStore ); Object clone(); void setDefault(); void getFields( RowMetaInterface row, String name, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space, Repository repository, IMetaStore metaStore ); String getXML(); 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 transMeta, Trans trans ); StepDataInterface getStepData(); TransformationType[] getSupportedTransformationTypes(); }### Answer: @Test public void testGetData() { DetectLastRowMeta meta = new DetectLastRowMeta(); assertTrue( meta.getStepData() instanceof DetectLastRowData ); }
### Question: DetectLastRowMeta extends BaseStepMeta implements StepMetaInterface { public void getFields( RowMetaInterface row, String name, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space, Repository repository, IMetaStore metaStore ) throws KettleStepException { if ( !Utils.isEmpty( resultfieldname ) ) { ValueMetaInterface v = new ValueMetaBoolean( space.environmentSubstitute( resultfieldname ) ); v.setOrigin( name ); row.addValueMeta( v ); } } String getResultFieldName(); void setResultFieldName( String resultfieldname ); void loadXML( Node stepnode, List<DatabaseMeta> databases, IMetaStore metaStore ); Object clone(); void setDefault(); void getFields( RowMetaInterface row, String name, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space, Repository repository, IMetaStore metaStore ); String getXML(); 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 transMeta, Trans trans ); StepDataInterface getStepData(); TransformationType[] getSupportedTransformationTypes(); }### Answer: @Test public void testGetFields() throws KettleStepException { DetectLastRowMeta meta = new DetectLastRowMeta(); meta.setDefault(); meta.setResultFieldName( "The Result" ); RowMeta rowMeta = new RowMeta(); meta.getFields( rowMeta, "this step", null, null, new Variables(), null, null ); assertEquals( 1, rowMeta.size() ); assertEquals( "The Result", rowMeta.getValueMeta( 0 ).getName() ); assertEquals( ValueMetaInterface.TYPE_BOOLEAN, rowMeta.getValueMeta( 0 ).getType() ); }
### Question: DetectLastRowMeta extends BaseStepMeta implements StepMetaInterface { public TransformationType[] getSupportedTransformationTypes() { return new TransformationType[] { TransformationType.Normal, }; } String getResultFieldName(); void setResultFieldName( String resultfieldname ); void loadXML( Node stepnode, List<DatabaseMeta> databases, IMetaStore metaStore ); Object clone(); void setDefault(); void getFields( RowMetaInterface row, String name, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space, Repository repository, IMetaStore metaStore ); String getXML(); 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 transMeta, Trans trans ); StepDataInterface getStepData(); TransformationType[] getSupportedTransformationTypes(); }### Answer: @Test public void testSupportedTransformationTypes() { DetectLastRowMeta meta = new DetectLastRowMeta(); assertEquals( 1, meta.getSupportedTransformationTypes().length ); assertEquals( TransformationType.Normal, meta.getSupportedTransformationTypes()[0] ); }
### Question: WebService extends BaseStep implements StepInterface { HttpPost getHttpMethod( String vURLService ) throws URISyntaxException { URIBuilder uriBuilder = new URIBuilder( vURLService ); HttpPost vHttpMethod = new HttpPost( uriBuilder.build() ); vHttpMethod.setHeader( "Content-Type", "text/xml;charset=UTF-8" ); String soapAction = "\"" + meta.getOperationNamespace(); if ( !meta.getOperationNamespace().endsWith( "/" ) ) { soapAction += "/"; } soapAction += meta.getOperationName() + "\""; logDetailed( BaseMessages.getString( PKG, "WebServices.Log.UsingRequestHeaderSOAPAction", soapAction ) ); vHttpMethod.setHeader( "SOAPAction", soapAction ); return vHttpMethod; } WebService( StepMeta aStepMeta, StepDataInterface aStepData, int value, TransMeta aTransMeta, Trans aTrans ); boolean processRow( StepMetaInterface metaInterface, StepDataInterface dataInterface ); boolean init( StepMetaInterface smi, StepDataInterface sdi ); void dispose( StepMetaInterface smi, StepDataInterface sdi ); static final String NS_PREFIX; }### Answer: @Test( expected = URISyntaxException.class ) public void newHttpMethodWithInvalidUrl() throws URISyntaxException { webServiceStep.getHttpMethod( NOT_VALID_URL ); }
### Question: WebService extends BaseStep implements StepInterface { static String getLocationFrom( HttpPost method ) { Header locationHeader = method.getFirstHeader( "Location" ); return locationHeader.getValue(); } WebService( StepMeta aStepMeta, StepDataInterface aStepData, int value, TransMeta aTransMeta, Trans aTrans ); boolean processRow( StepMetaInterface metaInterface, StepDataInterface dataInterface ); boolean init( StepMetaInterface smi, StepDataInterface sdi ); void dispose( StepMetaInterface smi, StepDataInterface sdi ); static final String NS_PREFIX; }### Answer: @Test public void getLocationFrom() { HttpPost postMethod = mock( HttpPost.class ); Header locationHeader = new BasicHeader( LOCATION_HEADER, TEST_URL ); doReturn( locationHeader ).when( postMethod ).getFirstHeader( LOCATION_HEADER ); assertEquals( TEST_URL, WebService.getLocationFrom( postMethod ) ); }
### Question: FragmentHandler extends AbstractXulEventHandler { protected String getFragment( DatabaseInterface database, String dbName, String extension, String defaultFragment ) { String fragment; String ext = ( extension == null ? "" : extension ); String databaseName = ( dbName == null ? "" : dbName ); String defaultFrag = ( defaultFragment == null ? "" : defaultFragment ); if ( database.getXulOverlayFile() != null ) { fragment = packagePath.concat( database.getXulOverlayFile() ).concat( ext ); } else { fragment = packagePath.concat( databaseName ).concat( ext ); } InputStream in = getClass().getClassLoader().getResourceAsStream( fragment.toLowerCase() ); if ( in == null ) { fragment = packagePath.concat( defaultFrag ); } return fragment; } FragmentHandler(); void refreshOptions(); Object getData(); void setData( Object arg0 ); }### Answer: @Test public void testGetFragment() throws Exception { DatabaseInterface dbInterface = mock( DatabaseInterface.class ); assertEquals( "org/pentaho/ui/database/", fragmentHandler.getFragment( dbInterface, null, null, null ) ); when( dbInterface.getXulOverlayFile() ).thenReturn( "overlay.xul" ); assertEquals( "org/pentaho/ui/database/", fragmentHandler.getFragment( dbInterface, null, null, null ) ); }
### Question: MappingInput extends BaseStep implements StepInterface { public void setConnectorSteps( StepInterface[] sourceSteps, List<MappingValueRename> valueRenames, String mappingStepname ) { if ( sourceSteps == null ) { throw new IllegalArgumentException( BaseMessages .getString( PKG, "MappingInput.Exception.IllegalArgumentSourceStep" ) ); } if ( valueRenames == null ) { throw new IllegalArgumentException( BaseMessages .getString( PKG, "MappingInput.Exception.IllegalArgumentValueRename" ) ); } if ( sourceSteps.length != 0 ) { if ( mappingStepname == null ) { throw new IllegalArgumentException( BaseMessages .getString( PKG, "MappingInput.Exception.IllegalArgumentStepName" ) ); } } for ( StepInterface sourceStep : sourceSteps ) { if ( !sourceStep.isMapping() ) { BlockingRowSet rowSet = new BlockingRowSet( getTransMeta().getSizeRowset() ); rowSet.setThreadNameFromToCopy( sourceStep.getStepname(), 0, mappingStepname, 0 ); sourceStep.getOutputRowSets().add( rowSet ); sourceStep.identifyErrorOutput(); getInputRowSets().add( rowSet ); } } data.valueRenames = valueRenames; data.sourceSteps = sourceSteps; } MappingInput( StepMeta stepMeta, StepDataInterface stepDataInterface, int copyNr, TransMeta transMeta, Trans trans ); void setTimeOut( int timeOut ); boolean processRow( StepMetaInterface smi, StepDataInterface sdi ); boolean init( StepMetaInterface smi, StepDataInterface sdi ); void setConnectorSteps( StepInterface[] sourceSteps, List<MappingValueRename> valueRenames, String mappingStepname ); }### Answer: @Test public void testSetConnectorSteps() throws Exception { when( stepMockHelper.transMeta.getSizeRowset() ).thenReturn( 1 ); MappingInputData mappingInputData = new MappingInputData(); MappingInput mappingInput = new MappingInput( stepMockHelper.stepMeta, mappingInputData, 0, stepMockHelper.transMeta, stepMockHelper.trans ); mappingInput.init( stepMockHelper.initStepMetaInterface, mappingInputData ); ValidatorData validatorData = new ValidatorData(); Validator previousStep = new Validator( stepMockHelper.stepMeta, validatorData, 0, stepMockHelper.transMeta, stepMockHelper.trans ); when( stepMockHelper.stepMeta.isDoingErrorHandling() ).thenReturn( true ); StepErrorMeta stepErrorMeta = mock( StepErrorMeta.class ); when( stepErrorMeta.getTargetStep() ).thenReturn( stepMockHelper.stepMeta ); when( stepMockHelper.stepMeta.getName() ).thenReturn( stepName ); when( stepMockHelper.stepMeta.getStepErrorMeta() ).thenReturn( stepErrorMeta ); StepInterface[] si = new StepInterface[] { previousStep }; mappingInput.setConnectorSteps( si, Collections.<MappingValueRename>emptyList(), stepName ); assertEquals( previousStep.getOutputRowSets().size(), 0 ); }
### Question: SetValueConstant extends BaseStep implements StepInterface { private void updateField( Object[] r ) throws Exception { for ( int i = 0; i < data.getFieldnr(); i++ ) { ValueMetaInterface targetValueMeta = data.getOutputRowMeta().getValueMeta( data.getFieldnrs()[i] ); ValueMetaInterface sourceValueMeta = data.getConvertRowMeta().getValueMeta( data.getFieldnrs()[i] ); if ( !Utils.isEmpty( meta.getReplaceMask()[i] ) ) { sourceValueMeta.setConversionMask( meta.getReplaceMask()[i] ); } sourceValueMeta.setStorageType( ValueMetaInterface.STORAGE_TYPE_NORMAL ); r[data.getFieldnrs()[i]] = targetValueMeta.convertData( sourceValueMeta, data.getRealReplaceByValues()[i] ); targetValueMeta.setStorageType( ValueMetaInterface.STORAGE_TYPE_NORMAL ); } } SetValueConstant( StepMeta stepMeta, StepDataInterface stepDataInterface, int copyNr, TransMeta transMeta, Trans trans ); boolean processRow( StepMetaInterface smi, StepDataInterface sdi ); boolean init( StepMetaInterface smi, StepDataInterface sdi ); }### Answer: @Test public void testUpdateField() throws Exception { SetValueConstant step = new SetValueConstant( smh.stepMeta, smh.stepDataInterface, 0, smh.transMeta, smh.trans ); ValueMetaInterface valueMeta = new ValueMetaString( "Field1" ); valueMeta.setStorageType( ValueMetaInterface.STORAGE_TYPE_BINARY_STRING ); RowMeta rowMeta = new RowMeta(); rowMeta.addValueMeta( valueMeta ); doReturn( new String[] { null } ).when( smh.initStepMetaInterface ).getReplaceMask(); doReturn( rowMeta ).when( smh.initStepDataInterface ).getConvertRowMeta(); doReturn( rowMeta ).when( smh.initStepDataInterface ).getOutputRowMeta(); doReturn( 1 ).when( smh.initStepDataInterface ).getFieldnr(); doReturn( new int[] { 0 } ).when( smh.initStepDataInterface ).getFieldnrs(); doReturn( new String[] { "foo" } ).when( smh.initStepDataInterface ).getRealReplaceByValues(); step.init( smh.initStepMetaInterface, smh.initStepDataInterface ); Method m = SetValueConstant.class.getDeclaredMethod( "updateField", Object[].class ); m.setAccessible( true ); Object[] row = new Object[] { null }; m.invoke( step, new Object[] { row } ); Assert.assertEquals( "foo", valueMeta.getString( row[0] ) ); }
### Question: MySQLBulkLoader extends BaseStep implements StepInterface { @Override public boolean init( StepMetaInterface smi, StepDataInterface sdi ) { meta = (MySQLBulkLoaderMeta) smi; data = (MySQLBulkLoaderData) sdi; if ( super.init( smi, sdi ) ) { if ( Utils.isEmpty( meta.getEnclosure() ) ) { data.quote = new byte[] {}; } else { data.quote = environmentSubstitute( meta.getEnclosure() ).getBytes(); } if ( Utils.isEmpty( meta.getDelimiter() ) ) { data.separator = "\t".getBytes(); } else { data.separator = environmentSubstitute( meta.getDelimiter() ).getBytes(); } data.newline = Const.CR.getBytes(); String realEncoding = environmentSubstitute( meta.getEncoding() ); data.bulkTimestampMeta = new ValueMetaDate( "timestampMeta" ); data.bulkTimestampMeta.setConversionMask( "yyyy-MM-dd HH:mm:ss" ); data.bulkTimestampMeta.setStringEncoding( realEncoding ); data.bulkDateMeta = new ValueMetaDate( "dateMeta" ); data.bulkDateMeta.setConversionMask( "yyyy-MM-dd" ); data.bulkDateMeta.setStringEncoding( realEncoding ); data.bulkNumberMeta = new ValueMetaNumber( "numberMeta" ); data.bulkNumberMeta.setConversionMask( "#.#" ); data.bulkNumberMeta.setGroupingSymbol( "," ); data.bulkNumberMeta.setDecimalSymbol( "." ); data.bulkNumberMeta.setStringEncoding( realEncoding ); data.bulkSize = Const.toLong( environmentSubstitute( meta.getBulkSize() ), -1L ); data.schemaTable = meta.getDatabaseMeta().getQuotedSchemaTableCombination( environmentSubstitute( meta.getSchemaName() ), environmentSubstitute( meta.getTableName() ) ); return true; } return false; } MySQLBulkLoader( StepMeta stepMeta, StepDataInterface stepDataInterface, int copyNr, TransMeta transMeta, Trans trans ); boolean execute( MySQLBulkLoaderMeta meta ); @Override boolean processRow( StepMetaInterface smi, StepDataInterface sdi ); @Override boolean init( StepMetaInterface smi, StepDataInterface sdi ); @Override void dispose( StepMetaInterface smi, StepDataInterface sdi ); }### Answer: @Test public void testVariableSubstitution() throws KettleException { lder.init( lmeta, ldata ); String is = null; is = new String( ldata.quote ); Assert.assertEquals( "'", is ); is = new String( ldata.separator ); Assert.assertEquals( ",", is ); Assert.assertEquals( "UTF8", ldata.bulkTimestampMeta.getStringEncoding() ); Assert.assertEquals( "UTF8", ldata.bulkDateMeta.getStringEncoding() ); Assert.assertEquals( "UTF8", ldata.bulkNumberMeta.getStringEncoding() ); Assert.assertEquals( "`someschema`.`sometable`", ldata.schemaTable ); }
### Question: FragmentHandler extends AbstractXulEventHandler { protected void showMessage( String message ) { try { XulMessageBox box = (XulMessageBox) document.createElement( "messagebox" ); box.setMessage( message ); box.open(); } catch ( XulException e ) { System.out.println( "Error creating messagebox " + e.getMessage() ); } } FragmentHandler(); void refreshOptions(); Object getData(); void setData( Object arg0 ); }### Answer: @Test public void testShowMessage() throws Exception { XulMessageBox messageBox = mock( XulMessageBox.class ); when( document.createElement( "messagebox" ) ).thenReturn( messageBox ); fragmentHandler.showMessage( null ); when( document.createElement( "messagebox" ) ).thenThrow( new XulException() ); fragmentHandler.showMessage( "" ); }
### Question: SortRowsMeta extends BaseStepMeta implements StepMetaInterface, Serializable { int getDefaultCollationStrength() { return getDefaultCollationStrength( Locale.getDefault() ); } SortRowsMeta(); boolean[] getAscending(); void setAscending( boolean[] ascending ); String getDirectory(); void setDirectory( String directory ); String[] getFieldName(); void setFieldName( String[] fieldName ); String getPrefix(); void setPrefix( String prefix ); @Override void loadXML( Node stepnode, List<DatabaseMeta> databases, IMetaStore metaStore ); void allocate( int nrfields ); @Override Object clone(); @Override void setDefault(); @Override String getXML(); @Override void readRep( Repository rep, IMetaStore metaStore, ObjectId id_step, List<DatabaseMeta> databases ); @Override void saveRep( Repository rep, IMetaStore metaStore, ObjectId id_transformation, ObjectId id_step ); @Override void getFields( RowMetaInterface inputRowMeta, String name, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space, Repository repository, IMetaStore metaStore ); @SuppressWarnings( "WeakerAccess" ) void assignSortingCriteria( RowMetaInterface inputRowMeta ); @Override void check( List<CheckResultInterface> remarks, TransMeta transMeta, StepMeta stepMeta, RowMetaInterface prev, String[] input, String[] output, RowMetaInterface info, VariableSpace space, Repository repository, IMetaStore metaStore ); @Override StepInterface getStep( StepMeta stepMeta, StepDataInterface stepDataInterface, int cnr, TransMeta transMeta, Trans trans ); @Override StepDataInterface getStepData(); String getSortSize(); void setSortSize( String sortSize ); boolean getCompressFiles(); void setCompressFiles( boolean compressFiles ); boolean isOnlyPassingUniqueRows(); void setOnlyPassingUniqueRows( boolean onlyPassingUniqueRows ); String getCompressFilesVariable(); void setCompressFilesVariable( String compressFilesVariable ); boolean[] getCaseSensitive(); void setCaseSensitive( boolean[] caseSensitive ); boolean[] getCollatorEnabled(); void setCollatorEnabled( boolean[] collatorEnabled ); int[] getCollatorStrength(); void setCollatorStrength( int[] collatorStrength ); String getFreeMemoryLimit(); void setFreeMemoryLimit( String freeMemoryLimit ); boolean[] getPreSortedField(); void setPreSortedField( boolean[] preSorted ); List<String> getGroupFields(); boolean isGroupSortEnabled(); @AfterInjection void afterInjectionSynchronization(); }### Answer: @Test public void testGetDefaultStrength() { SortRowsMeta srm = new SortRowsMeta(); int usStrength = srm.getDefaultCollationStrength( Locale.US ); assertEquals( Collator.TERTIARY, usStrength ); assertEquals( Collator.IDENTICAL, srm.getDefaultCollationStrength( null ) ); }
### Question: Validator extends BaseStep implements StepInterface { KettleValidatorException assertNumeric( ValueMetaInterface valueMeta, Object valueData, Validation field ) throws KettleValueException { if ( valueMeta.isNumeric() \|\| containsOnlyDigits( valueMeta.getString( valueData ) ) ) { return null; } return new KettleValidatorException( this, field, KettleValidatorException.ERROR_NON_NUMERIC_DATA, BaseMessages.getString( PKG, "Validator.Exception.NonNumericDataNotAllowed", field.getFieldName(), valueMeta.toStringMeta() ), field.getFieldName() ); } Validator( StepMeta stepMeta, StepDataInterface stepDataInterface, int copyNr, TransMeta transMeta, Trans trans ); boolean processRow( StepMetaInterface smi, StepDataInterface sdi ); boolean init( StepMetaInterface smi, StepDataInterface sdi ); }### Answer: @Test public void assertNumeric_StringWithDigits() throws Exception { ValueMetaString metaString = new ValueMetaString( "string-with-digits" ); assertNull( "Strings with digits are allowed", validator.assertNumeric( metaString, "123", new Validation() ) ); } @Test public void assertNumeric_String() throws Exception { ValueMetaString metaString = new ValueMetaString( "string" ); assertNotNull( "General strings are not allowed", validator.assertNumeric( metaString, "qwerty", new Validation() ) ); }
### Question: SimpleMapping extends BaseStep implements StepInterface { public void dispose( StepMetaInterface smi, StepDataInterface sdi ) { if ( getData().wasStarted ) { if ( !getData().mappingTrans.isFinished() ) { getData().mappingTrans.waitUntilFinished(); } getTrans().removeActiveSubTransformation( getStepname() ); if ( getData().mappingTrans.getErrors() > 0 ) { logError( BaseMessages.getString( PKG, "SimpleMapping.Log.ErrorOccurredInSubTransformation" ) ); setErrors( 1 ); } } super.dispose( smi, sdi ); } SimpleMapping( StepMeta stepMeta, StepDataInterface stepDataInterface, int copyNr, TransMeta transMeta, Trans trans ); boolean processRow( StepMetaInterface smi, StepDataInterface sdi ); void prepareMappingExecution(); static void addInputRenames( List<MappingValueRename> renameList, List<MappingValueRename> addRenameList ); boolean init( StepMetaInterface smi, StepDataInterface sdi ); void dispose( StepMetaInterface smi, StepDataInterface sdi ); void stopRunning( StepMetaInterface stepMetaInterface, StepDataInterface stepDataInterface ); void stopAll(); Trans getMappingTrans(); void addRowListener( RowListener rowListener ); SimpleMappingData getData(); }### Answer: @Test public void testDispose() throws KettleException { when( stepMockHelper.trans.getErrors() ).thenReturn( 0 ); when( stepMockHelper.trans.isFinished() ).thenReturn( Boolean.FALSE ); simpleMpData.wasStarted = true; smp = new SimpleMapping( stepMockHelper.stepMeta, stepMockHelper.stepDataInterface, 0, stepMockHelper.transMeta, stepMockHelper.trans ); smp.init( stepMockHelper.initStepMetaInterface, simpleMpData ); smp.dispose( stepMockHelper.processRowsStepMetaInterface, simpleMpData ); verify( stepMockHelper.trans, times( 1 ) ).isFinished(); verify( stepMockHelper.trans, times( 1 ) ).waitUntilFinished(); verify( stepMockHelper.trans, times( 1 ) ).removeActiveSubTransformation( anyString() ); }
### Question: MondrianInputMeta extends BaseStepMeta implements StepMetaInterface { public StepDataInterface getStepData() { return new MondrianData(); } MondrianInputMeta(); DatabaseMeta getDatabaseMeta(); void setDatabaseMeta( DatabaseMeta database ); boolean isVariableReplacementActive(); void setVariableReplacementActive( boolean variableReplacementActive ); String getSQL(); void setSQL( String sql ); void loadXML( Node stepnode, List<DatabaseMeta> databases, IMetaStore metaStore ); Object clone(); void setDefault(); void getFields( RowMetaInterface row, String origin, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space, Repository repository, IMetaStore metaStore ); String getXML(); 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 transMeta, Trans trans ); StepDataInterface getStepData(); void analyseImpact( List<DatabaseImpact> impact, TransMeta transMeta, StepMeta stepMeta, RowMetaInterface prev, String[] input, String[] output, RowMetaInterface info, Repository repository, IMetaStore metaStore ); DatabaseMeta[] getUsedDatabaseConnections(); String getCatalog(); void setCatalog( String catalog ); String getRole(); void setRole( String role ); String exportResources( VariableSpace space, Map<String, ResourceDefinition> definitions, ResourceNamingInterface resourceNamingInterface, Repository repository, IMetaStore metaStore ); }### Answer: @Test public void testGetData() { MondrianInputMeta meta = new MondrianInputMeta(); assertTrue( meta.getStepData() instanceof MondrianData ); }
### Question: ReadAllCache implements DatabaseLookupData.Cache { @Override public void storeRowInCache( DatabaseLookupMeta meta, RowMetaInterface lookupMeta, Object[] lookupRow, Object[] add ) { throw new UnsupportedOperationException( "This cache is read-only" ); } ReadAllCache( DatabaseLookupData stepData, Object[][] keys, RowMetaInterface keysMeta, Object[][] data ); @Override Object[] getRowFromCache( RowMetaInterface lookupMeta, Object[] lookupRow ); @Override void storeRowInCache( DatabaseLookupMeta meta, RowMetaInterface lookupMeta, Object[] lookupRow, Object[] add ); }### Answer: @Test( expected = UnsupportedOperationException.class ) public void storeRowInCache_ThrowsException() throws Exception { buildCache( "" ).storeRowInCache( new DatabaseLookupMeta(), keysMeta.clone(), keys[ 0 ], data[ 0 ] ); }
### Question: DeserializedRow implements Row { @Override public Object[] getObjects() { return Collections.unmodifiableList( objects ).toArray(); } DeserializedRow( List<String> names, List<Class> types, List<Object> objects ); @Override List<String> getColumnNames(); @Override Object[] getObjects(); @Override boolean equals( Object o ); @Override int hashCode(); }### Answer: @Test public void testRow() throws Exception { Date date = new Date(); URI uri = new URI( "http: List<Object> objects = new ArrayList<>(); objects.add( 100 ); objects.add( 100.50 ); BigDecimal bigDecimal = new BigDecimal( "10000000000000000000.50" ); objects.add( bigDecimal ); objects.add( true ); objects.add( date ); objects.add( "A String" ); objects.add( uri ); List<String> names = new ArrayList<>(); names.add( "some int" ); names.add( "some Double" ); names.add( "some Decimal" ); names.add( "some Boolean" ); names.add( "some Date" ); names.add( "some String" ); names.add( "some Serializable" ); List<Class> classes = Arrays .asList( Integer.class, Double.class, BigDecimal.class, Boolean.class, Date.class, String.class, Object.class ); Row row = new DeserializedRow( names, classes, objects ); assertEquals( new Integer( 100 ), row.getObjects()[ 0 ] ); assertEquals( 100.50, (double) row.getObjects()[ 1 ], 0.001D ); assertEquals( bigDecimal, row.getObjects()[ 2 ] ); assertTrue( (Boolean) row.getObjects()[ 3 ] ); assertEquals( date, row.getObjects()[ 4 ] ); assertEquals( "A String", row.getObjects()[ 5 ] ); assertEquals( uri, row.getObjects()[ 6 ] ); }
### Question: GetRepositoryNames extends BaseStep implements StepInterface { @Override public boolean init( StepMetaInterface smi, StepDataInterface sdi ) { meta = (GetRepositoryNamesMeta) smi; data = (GetRepositoryNamesData) sdi; if ( super.init( smi, sdi ) ) { try { data.list = getRepositoryObjects(); } catch ( Exception e ) { logError( "Error initializing step: ", e ); return false; } data.rownr = 1L; data.filenr = 0; return true; } return false; } GetRepositoryNames( StepMeta stepMeta, StepDataInterface stepDataInterface, int copyNr, TransMeta transMeta, Trans trans ); @Override boolean processRow( StepMetaInterface smi, StepDataInterface sdi ); @Override boolean init( StepMetaInterface smi, StepDataInterface sdi ); }### Answer: @Test public void testGetRepoList_includeSubfolders() throws KettleException { init( repo, "/", true, ".", "", All, 4 ); } @Test public void testGetRepoList_excludeSubfolders() throws KettleException { init( repo, "/", false, ".", "", All, 0 ); } @Test public void testGetRepoList_transOnly() throws KettleException { init( repo, "/", true, ".", "", Transformations, 2 ); } @Test public void testGetRepoList_jobsOnly() throws KettleException { init( repo, "/", true, ".", "", Jobs, 2 ); } @Test public void testGetRepoList_nameMask() throws KettleException { init( repo, "/", true, "Trans.", "", All, 2 ); } @Test public void testGetRepoList_withoutNameMask() throws KettleException { init( repo, "/", true, "", "", All, 4 ); } @Test public void testGetRepoList_excludeNameMask() throws KettleException { init( repo, "/", true, ".", "Trans1.", All, 3 ); } @Test public void testGetRepoList_includeSubfolders_Extended() throws KettleException { init( repoExtended, "/", true, ".", "", All, 4 ); } @Test public void testGetRepoList_excludeSubfolders_Extended() throws KettleException { init( repoExtended, "/", false, ".", "", All, 0 ); } @Test public void testGetRepoList_transOnly_Extended() throws KettleException { init( repoExtended, "/", true, ".", "", Transformations, 2 ); } @Test public void testGetRepoList_jobsOnly_Extended() throws KettleException { init( repoExtended, "/", true, ".", "", Jobs, 2 ); } @Test public void testGetRepoList_nameMask_Extended() throws KettleException { init( repoExtended, "/", true, "Trans.", "", All, 2 ); } @Test public void testGetRepoList_withoutNameMask_Extended() throws KettleException { init( repoExtended, "/", true, "", "", All, 4 ); } @Test public void testGetRepoList_excludeNameMask_Extended() throws KettleException { init( repoExtended, "/", true, ".", "Trans1.", All, 3 ); } @Test public void testShowHidden() throws KettleException { IUser user = Mockito.mock( IUser.class ); Mockito.when( user.isAdmin() ).thenReturn( true ); Mockito.when( repoExtended.getUserInfo() ).thenReturn( user ); init( repoExtended, "/", false, ".", "", All, 0 ); Mockito.verify( repoExtended, Mockito.never() ) .loadRepositoryDirectoryTree( Mockito.anyString(), Mockito.anyString(), Mockito.anyInt(), Mockito.eq( false ), Mockito.anyBoolean(), anyBoolean() ); Mockito.when( user.isAdmin() ).thenReturn( false ); init( repoExtended, "/", false, ".", "", All, 0 ); Mockito.verify( repoExtended ) .loadRepositoryDirectoryTree( Mockito.anyString(), Mockito.anyString(), Mockito.anyInt(), Mockito.eq( false ), Mockito.anyBoolean(), Mockito.anyBoolean() ); }
### Question: Messages { public static ResourceBundle getBundle() { if ( RESOURCE_BUNDLE == null ) { RESOURCE_BUNDLE = ResourceBundle.getBundle( BUNDLE_NAME ); } return RESOURCE_BUNDLE; } private Messages(); static ResourceBundle getBundle(); static String getString( String key ); static String getString( String key, String param1 ); static String getString( String key, String param1, String param2 ); static String getString( String key, String param1, String param2, String param3 ); static String getString( String key, String param1, String param2, String param3, String param4 ); }### Answer: @Test public void testGetBundle() throws Exception { assertNotNull( Messages.getBundle() ); }
### Question: ActingPrincipal implements Principal, Serializable { public boolean equals( Object other ) { if ( other instanceof ActingPrincipal ) { ActingPrincipal that = (ActingPrincipal) other; return ( this.isAnonymous() && that.isAnonymous() ) \|\| ( this.getName() != null && this.getName().equals( that.getName() ) ); } else { return false; } } 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 equals() throws Exception { principal1 = new ActingPrincipal( "suzy" ); principal2 = new ActingPrincipal( "joe" ); assertFalse( principal1.equals( principal2 ) ); assertFalse( principal1.equals( ActingPrincipal.ANONYMOUS ) ); principal2 = new ActingPrincipal( "suzy" ); assertTrue( principal1.equals( principal2 ) ); principal2 = ActingPrincipal.ANONYMOUS; assertTrue( principal2.equals( ActingPrincipal.ANONYMOUS ) ); }
### Question: AccessOutputData extends BaseStepData implements StepDataInterface { void createDatabase( File databaseFile ) throws IOException { db = Database.create( databaseFile ); } AccessOutputData(); public Database db; public Table table; public List<Object[]> rows; public RowMetaInterface outputRowMeta; public boolean oneFileOpened; }### Answer: @Test public void testCreateDatabase() throws IOException { assertNull( data.db ); data.createDatabase( mdbFile ); assertNotNull( data.db ); assertTrue( mdbFile.exists() ); assertNull( data.table ); data.truncateTable(); assertNull( data.table ); data.closeDatabase(); }
### 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: ReplaceString extends BaseStep implements StepInterface { synchronized Object[] getOneRow( RowMetaInterface rowMeta, Object[] row ) throws KettleException { Object[] rowData = RowDataUtil.resizeArray( row, data.outputRowMeta.size() ); int index = 0; Set<Integer> numFieldsAlreadyBeenTransformed = new HashSet<Integer>(); for ( int i = 0; i < data.numFields; i++ ) { RowMetaInterface currentRowMeta = ( numFieldsAlreadyBeenTransformed.contains( data.inStreamNrs[i] ) ) ? data.outputRowMeta : getInputRowMeta(); String value = replaceString( currentRowMeta.getString( rowData, data.inStreamNrs[i] ), data.patterns[i], getResolvedReplaceByString( i, row ) ); if ( Utils.isEmpty( data.outStreamNrs[i] ) ) { rowData[data.inStreamNrs[i]] = value; numFieldsAlreadyBeenTransformed.add( data.inStreamNrs[i] ); } else { rowData[data.inputFieldsNr + index++] = value; } } return rowData; } ReplaceString( StepMeta stepMeta, StepDataInterface stepDataInterface, int copyNr, TransMeta transMeta, Trans trans ); static String replaceString( String originalString, Pattern pattern, String replaceByString ); boolean processRow( StepMetaInterface smi, StepDataInterface sdi ); boolean init( StepMetaInterface smi, StepDataInterface sdi ); void dispose( StepMetaInterface smi, StepDataInterface sdi ); }### Answer: @Test public void testGetOneRow() throws Exception { ReplaceStringData data = new ReplaceStringData(); ReplaceString replaceString = new ReplaceString( stepMockHelper.stepMeta, data, 0, stepMockHelper.transMeta, stepMockHelper.trans ); RowMetaInterface inputRowMeta = new RowMeta(); inputRowMeta.addValueMeta( 0, new ValueMetaString( "SomeDataMeta" ) ); inputRowMeta.addValueMeta( 1, new ValueMetaString( "AnotherDataMeta" ) ); replaceString.init( stepMockHelper.processRowsStepMetaInterface, data ); replaceString.setInputRowMeta( inputRowMeta ); data.outputRowMeta = inputRowMeta; data.outputRowMeta.addValueMeta( new ValueMetaString( "AnotherDataMeta" ) ); data.inputFieldsNr = 2; data.numFields = 2; data.inStreamNrs = new int[] { 1, 1 }; data.patterns = new Pattern[] { Pattern.compile( "a" ), Pattern.compile( "t" ) }; data.replaceFieldIndex = new int[] { -1, -1 }; data.outStreamNrs = new String[] { "", "1" }; data.replaceByString = new String[] { "1", "2" }; data.setEmptyString = new boolean[] { false, false }; Object[] output = replaceString.getOneRow( inputRowMeta, row ); assertArrayEquals( "Output varies", expectedRow, output ); }
### Question: ReplaceString extends BaseStep implements StepInterface { public boolean init( StepMetaInterface smi, StepDataInterface sdi ) { meta = (ReplaceStringMeta) smi; data = (ReplaceStringData) sdi; if ( super.init( smi, sdi ) ) { return true; } return false; } ReplaceString( StepMeta stepMeta, StepDataInterface stepDataInterface, int copyNr, TransMeta transMeta, Trans trans ); static String replaceString( String originalString, Pattern pattern, String replaceByString ); boolean processRow( StepMetaInterface smi, StepDataInterface sdi ); boolean init( StepMetaInterface smi, StepDataInterface sdi ); void dispose( StepMetaInterface smi, StepDataInterface sdi ); }### Answer: @Test public void testSynchronizeDifferentFieldsArraysLengths() throws Exception { ReplaceStringData data = new ReplaceStringData(); ReplaceString replaceString = new ReplaceString( stepMockHelper.stepMeta, data, 0, stepMockHelper.transMeta, stepMockHelper.trans ); ReplaceStringMeta meta = new ReplaceStringMeta(); replaceString.init( meta, data ); meta.setFieldInStream( new String[] { "input1", "input2" } ); meta.setFieldOutStream( new String[] { "out" } ); meta.setUseRegEx( new int[] { 1 } ); meta.setCaseSensitive( new int[] { 0 } ); meta.setWholeWord( new int[] { 1 } ); meta.setReplaceString( new String[] { "string" } ); meta.setReplaceByString( new String[] { "string" } ); meta.setEmptyString( new boolean[] { true } ); meta.setFieldReplaceByString( new String[] { "string" } ); meta.afterInjectionSynchronization(); Assert.assertEquals( meta.getFieldInStream().length, meta.getFieldOutStream().length ); Assert.assertEquals( StringUtils.EMPTY, meta.getFieldOutStream()[ 1 ] ); Assert.assertEquals( meta.getFieldInStream().length, meta.getUseRegEx().length ); Assert.assertEquals( 0, meta.getUseRegEx()[ 1 ] ); Assert.assertEquals( meta.getFieldInStream().length, meta.getCaseSensitive().length ); Assert.assertEquals( 0, meta.getCaseSensitive()[ 1 ] ); Assert.assertEquals( meta.getFieldInStream().length, meta.getWholeWord().length ); Assert.assertEquals( 0, meta.getWholeWord()[ 1 ] ); Assert.assertEquals( meta.getFieldInStream().length, meta.getReplaceString().length ); Assert.assertEquals( StringUtils.EMPTY, meta.getReplaceString()[ 1 ] ); Assert.assertEquals( meta.getFieldInStream().length, meta.getReplaceByString().length ); Assert.assertEquals( StringUtils.EMPTY, meta.getReplaceByString()[ 1 ] ); Assert.assertEquals( meta.getFieldInStream().length, meta.isSetEmptyString().length ); Assert.assertEquals( false, meta.isSetEmptyString()[ 1 ] ); Assert.assertEquals( meta.getFieldInStream().length, meta.getFieldReplaceByString().length ); Assert.assertEquals( StringUtils.EMPTY, meta.getFieldReplaceByString()[ 1 ] ); }
### 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 registerUrl( String urlString ) { if ( urlString == null \|\| addedAllClusters == true ) { return; } if ( urlString.startsWith( VARIABLE_START ) ) { addAllClusters(); } Pattern r = Pattern.compile( URL_PATTERN ); Matcher m = r.matcher( urlString ); if ( m.find() ) { String protocol = m.group( PARSE_URL_SCHEME ); String clusterName = m.group( PARSE_URL_AUTHORITY ); if ( "hc".equals( protocol ) ) { if ( clusterName.startsWith( VARIABLE_START ) ) { addAllClusters(); } addClusterToMeta( clusterName ); } } } 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 testRegisterUrlNc() throws Exception { namedClusterEmbedManager.registerUrl( "hc: verify( mockMetaStoreFactory ).saveElement( mockNamedCluster1 ); } @Test public void testRegisterUrlNotNc() throws Exception { namedClusterEmbedManager.registerUrl( "hdfs: verify( mockMetaStoreFactory, never() ).saveElement( any() ); } @Test public void testRegisterUrlRegularFile() throws Exception { namedClusterEmbedManager.registerUrl( "/" + CLUSTER1_NAME + "/dir1/dir2" ); verify( mockMetaStoreFactory, never() ).saveElement( any() ); } @Test public void testRegisterUrlFullVariable() throws Exception { when( mockNamedClusterService.listNames( mockMeta.getMetaStore() ) ) .thenReturn( Arrays.asList( new String[] { CLUSTER1_NAME, CLUSTER2_NAME } ) ); namedClusterEmbedManager.registerUrl( "${variable)" ); verify( mockMetaStoreFactory ).saveElement( mockNamedCluster1 ); verify( mockMetaStoreFactory ).saveElement( mockNamedCluster2 ); } @Test public void testRegisterUrlClusterVariable() throws Exception { when( mockNamedClusterService.listNames( mockMeta.getMetaStore() ) ) .thenReturn( Arrays.asList( new String[] { CLUSTER1_NAME, CLUSTER2_NAME } ) ); namedClusterEmbedManager.registerUrl( "hc: verify( mockMetaStoreFactory ).saveElement( mockNamedCluster1 ); verify( mockMetaStoreFactory ).saveElement( mockNamedCluster2 ); } @Test public void testRegisterUrlAlreadyRegistered() throws Exception { when( mockMetaStoreFactory.loadElement( CLUSTER1_NAME ) ).thenReturn( mockNamedCluster1 ); namedClusterEmbedManager.registerUrl( "hc: verify( mockMetaStoreFactory, times(0 ) ).saveElement( mockNamedCluster1 ); } @Test public void testRegisterUrlAlreadyRegistered() throws Exception { when( mockMetaStoreFactory.loadElement( CLUSTER1_NAME ) ).thenReturn( mockNamedCluster1 ); namedClusterEmbedManager.registerUrl( "hc: verify( mockMetaStoreFactory, times( 0 ) ).saveElement( mockNamedCluster1 ); }
### Question: TransformationMap { public List<SocketPortAllocation> getHostServerSocketPorts( String hostname ) { List<SocketPortAllocation> ports = hostServerSocketPortsMap.get( hostname ); return ports == null ? Collections.emptyList() : Collections.unmodifiableList( ports ); } TransformationMap(); void addTransformation( String transformationName, String containerObjectId, Trans trans, TransConfiguration transConfiguration ); void registerTransformation( Trans trans, TransConfiguration transConfiguration ); Trans getTransformation( String transformationName ); Trans getTransformation( CarteObjectEntry entry ); TransConfiguration getConfiguration( String transformationName ); TransConfiguration getConfiguration( CarteObjectEntry entry ); void removeTransformation( CarteObjectEntry entry ); List<CarteObjectEntry> getTransformationObjects(); SocketPortAllocation allocateServerSocketPort( int portRangeStart, String hostname, String clusteredRunId, String transformationName, String sourceSlaveName, String sourceStepName, String sourceStepCopy, String targetSlaveName, String targetStepName, String targetStepCopy ); void deallocateServerSocketPorts( String transName, String carteObjectId ); void deallocateServerSocketPorts( CarteObjectEntry entry ); void deallocateServerSocketPort( int port, String hostname ); CarteObjectEntry getFirstCarteObjectEntry( String transName ); SlaveServerConfig getSlaveServerConfig(); void setSlaveServerConfig( SlaveServerConfig slaveServerConfig ); List<SocketPortAllocation> getHostServerSocketPorts( String hostname ); SlaveSequence getSlaveSequence( String name ); boolean isAutomaticSlaveSequenceCreationAllowed(); SlaveSequence createSlaveSequence( String name ); }### Answer: @Test public void getHostServerSocketPorts() { transformationMap.allocateServerSocketPort( 1, TEST_HOST, CLUSTERED_RUN_ID, TEST_TRANSFORMATION_NAME, TEST_SOURCE_SLAVE_NAME, TEST_SOURCE_STEP_NAME, TEST_SOURCE_STEP_COPY, TEST_TARGET_SLAVE_NAME, TEST_TARGET_STEP_NAME, TEST_TARGET_STEP_COPY ); List<SocketPortAllocation> actualResult = transformationMap.getHostServerSocketPorts( TEST_HOST ); assertNotNull( actualResult ); assertEquals( 1, actualResult.size() ); } @Test public void getHostServerSocketPortsWithoutAllocatedPorts() { List<SocketPortAllocation> actualResult = transformationMap.getHostServerSocketPorts( TEST_HOST ); assertNotNull( actualResult ); assertTrue( actualResult.isEmpty() ); }
### 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: GroupBy extends BaseStep implements StepInterface { void addToBuffer( Object[] row ) throws KettleFileException { data.bufferList.add( row ); if ( data.bufferList.size() > 5000 && data.rowsOnFile == 0 ) { String pathToTmp = environmentSubstitute( getMeta().getDirectory() ); try { File ioFile = new File( pathToTmp ); if ( !ioFile.exists() ) { pathToTmp = retrieveVfsPath( pathToTmp ); } data.tempFile = File.createTempFile( getMeta().getPrefix(), ".tmp", new File( pathToTmp ) ); data.fosToTempFile = new FileOutputStream( data.tempFile ); data.dosToTempFile = new DataOutputStream( data.fosToTempFile ); data.firstRead = true; } catch ( IOException e ) { throw new KettleFileException( BaseMessages.getString( PKG, "GroupBy.Exception.UnableToCreateTemporaryFile" ), e ); } Object[] oldest = data.bufferList.get( 0 ); data.inputRowMeta.writeData( data.dosToTempFile, oldest ); data.bufferList.remove( 0 ); data.rowsOnFile++; } } 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 testAddToBuffer() throws KettleException, FileSystemException { GroupByData groupByData = new GroupByData(); ArrayList listMock = mock( ArrayList.class ); when( listMock.size() ).thenReturn( 5001 ); groupByData.bufferList = listMock; groupByData.rowsOnFile = 0; RowMetaInterface inputRowMetaMock = mock( RowMetaInterface.class ); groupByData.inputRowMeta = inputRowMetaMock; GroupBy groupBySpy = Mockito.spy( new GroupBy( mockHelper.stepMeta, groupByData, 0, mockHelper.transMeta, mockHelper.trans ) ); GroupByMeta groupByMetaMock = mock( GroupByMeta.class ); when( groupByMetaMock.getPrefix() ).thenReturn( "group-by-test-temp-file-" ); when( groupBySpy.getMeta() ).thenReturn( groupByMetaMock ); String userDir = System.getProperty( "user.dir" ); String vfsFilePath = "file: when( groupBySpy.environmentSubstitute( anyString() ) ).thenReturn( vfsFilePath ); Object[] row = { "abc" }; groupBySpy.addToBuffer( row ); assertTrue( groupByData.tempFile.exists() ); groupBySpy.dispose( groupByMetaMock, groupByData ); assertFalse( groupByData.tempFile.exists() ); verify( groupBySpy, times( 1 ) ).retrieveVfsPath( anyString() ); }
### Question: StaxPoiSheet implements KSheet { @Override public KCell[] getRow( int rownr ) { if ( rownr < 0 \|\| rownr >= numRows ) { throw new ArrayIndexOutOfBoundsException( rownr ); } if ( rownr + 1 < firstRow ) { return new KCell[0]; } if ( rownr > 0 && currentRow == rownr + 1 ) { return currentRowCells; } try { if ( currentRow >= rownr + 1 ) { resetSheetReader(); } while ( sheetReader.hasNext() ) { int event = sheetReader.next(); if ( event == XMLStreamConstants.START_ELEMENT && sheetReader.getLocalName().equals( "row" ) ) { String rowIndicator = sheetReader.getAttributeValue( null, "r" ); currentRow = Integer.parseInt( rowIndicator ); if ( currentRow < rownr + 1 ) { continue; } currentRowCells = parseRow(); return currentRowCells; } } } catch ( Exception e ) { throw new RuntimeException( e ); } numRows = currentRow; return new KCell[] {}; } 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 testNullDateCell() throws Exception { final String sheetId = "1"; final String sheetName = "Sheet 1"; XSSFReader reader = mockXSSFReader( sheetId, SHEET_DATE_NO_V, mockSharedStringsTable( "Some Date" ), mockStylesTable( Collections.singletonMap( 2, 165 ), Collections.singletonMap( 165, "M/D/YYYY" ) ) ); StaxPoiSheet spSheet = new StaxPoiSheet( reader, sheetName, sheetId ); KCell cell = spSheet.getRow( 1 )[0]; assertNotNull( cell ); assertEquals( KCellType.DATE, cell.getType() ); cell = spSheet.getRow( 2 )[0]; assertNull( "cell must be null", cell ); } @Test public void testReadSameRow() throws Exception { KSheet sheet1 = getSampleSheet(); KCell[] row = sheet1.getRow( 3 ); assertEquals( "Two", row[1].getValue() ); row = sheet1.getRow( 3 ); assertEquals( "Two", row[1].getValue() ); } @Test public void testReadRowRA() throws Exception { KSheet sheet1 = getSampleSheet(); KCell[] row = sheet1.getRow( 4 ); assertEquals( "Three", row[1].getValue() ); row = sheet1.getRow( 2 ); assertEquals( "One", row[1].getValue() ); } @Test public void testReadEmptyRow() throws Exception { KSheet sheet1 = getSampleSheet(); KCell[] row = sheet1.getRow( 0 ); assertEquals( "empty row expected", 0, row.length ); }
### 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: StepErrorMeta extends ChangedFlag implements XMLInterface, Cloneable { public RowMetaInterface getErrorRowMeta( long nrErrors, String errorDescriptions, String fieldNames, String errorCodes ) { RowMetaInterface row = new RowMeta(); String nrErr = variables.environmentSubstitute( getNrErrorsValuename() ); if ( !Utils.isEmpty( nrErr ) ) { ValueMetaInterface v = new ValueMetaInteger( nrErr ); v.setLength( 3 ); row.addValueMeta( v ); } String errDesc = variables.environmentSubstitute( getErrorDescriptionsValuename() ); if ( !Utils.isEmpty( errDesc ) ) { ValueMetaInterface v = new ValueMetaString( errDesc ); row.addValueMeta( v ); } String errFields = variables.environmentSubstitute( getErrorFieldsValuename() ); if ( !Utils.isEmpty( errFields ) ) { ValueMetaInterface v = new ValueMetaString( errFields ); row.addValueMeta( v ); } String errCodes = variables.environmentSubstitute( getErrorCodesValuename() ); if ( !Utils.isEmpty( errCodes ) ) { ValueMetaInterface v = new ValueMetaString( errCodes ); row.addValueMeta( v ); } return row; } StepErrorMeta( VariableSpace space, StepMeta sourceStep ); StepErrorMeta( VariableSpace space, StepMeta sourceStep, StepMeta targetStep ); StepErrorMeta( VariableSpace space, StepMeta sourceStep, StepMeta targetStep, String nrErrorsValuename, String errorDescriptionsValuename, String errorFieldsValuename, String errorCodesValuename ); StepErrorMeta( VariableSpace variables, Node node, List<StepMeta> steps ); @Override StepErrorMeta clone(); @Override String getXML(); String getErrorCodesValuename(); void setErrorCodesValuename( String errorCodesValuename ); String getErrorDescriptionsValuename(); void setErrorDescriptionsValuename( String errorDescriptionsValuename ); String getErrorFieldsValuename(); void setErrorFieldsValuename( String errorFieldsValuename ); String getNrErrorsValuename(); void setNrErrorsValuename( String nrErrorsValuename ); StepMeta getTargetStep(); void setTargetStep( StepMeta targetStep ); StepMeta getSourceStep(); void setSourceStep( StepMeta sourceStep ); boolean isEnabled(); void setEnabled( boolean enabled ); RowMetaInterface getErrorFields(); RowMetaInterface getErrorRowMeta( long nrErrors, String errorDescriptions, String fieldNames, String errorCodes ); void addErrorRowData( Object[] row, int startIndex, long nrErrors, String errorDescriptions, String fieldNames, String errorCodes ); String getMaxErrors(); void setMaxErrors( String maxErrors ); String getMaxPercentErrors(); void setMaxPercentErrors( String maxPercentErrors ); String getMinPercentRows(); void setMinPercentRows( String minRowsForPercent ); static final String XML_ERROR_TAG; static final String XML_SOURCE_STEP_TAG; static final String XML_TARGET_STEP_TAG; }### Answer: @Test public void testGetErrorRowMeta() { VariableSpace vars = new Variables(); vars.setVariable( "VarNumberErrors", "nbrErrors" ); vars.setVariable( "VarErrorDescription", "errorDescription" ); vars.setVariable( "VarErrorFields", "errorFields" ); vars.setVariable( "VarErrorCodes", "errorCodes" ); StepErrorMeta testObject = new StepErrorMeta( vars, new StepMeta(), new StepMeta(), "${VarNumberErrors}", "${VarErrorDescription}", "${VarErrorFields}", "${VarErrorCodes}" ); RowMetaInterface result = testObject.getErrorRowMeta( 10, "some data was bad", "factId", "BAD131" ); assertNotNull( result ); assertEquals( 4, result.size() ); assertEquals( ValueMetaInterface.TYPE_INTEGER, result.getValueMeta( 0 ).getType() ); assertEquals( "nbrErrors", result.getValueMeta( 0 ).getName() ); assertEquals( ValueMetaInterface.TYPE_STRING, result.getValueMeta( 1 ).getType() ); assertEquals( "errorDescription", result.getValueMeta( 1 ).getName() ); assertEquals( ValueMetaInterface.TYPE_STRING, result.getValueMeta( 2 ).getType() ); assertEquals( "errorFields", result.getValueMeta( 2 ).getName() ); assertEquals( ValueMetaInterface.TYPE_STRING, result.getValueMeta( 3 ).getType() ); assertEquals( "errorCodes", result.getValueMeta( 3 ).getName() ); }
### 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: TransSupplier implements Supplier<Trans> { public Trans get() { if ( Utils.isEmpty( transMeta.getVariable( "engine" ) ) ) { log.logBasic( "Using legacy execution engine" ); return fallbackSupplier.get(); } Variables variables = new Variables(); variables.initializeVariablesFrom( null ); String version = variables.getVariable( "KETTLE_AEL_PDI_DAEMON_VERSION", "2.0" ); if ( Const.toDouble( version, 1 ) >= 2 ) { String protocol = transMeta.getVariable( "engine.protocol" ); String host = transMeta.getVariable( "engine.host" ); String port = transMeta.getVariable( "engine.port" ); boolean ssl = "https".equalsIgnoreCase( protocol ) \|\| "wss".equalsIgnoreCase( protocol ); return new TransWebSocketEngineAdapter( transMeta, host, port, ssl ); } else { try { return PluginRegistry.getInstance().getPlugins( EnginePluginType.class ).stream() .filter( useThisEngine() ) .findFirst() .map( plugin -> (Engine) loadPlugin( plugin ) ) .map( engine -> { log.logBasic( "Using execution engine " + engine.getClass().getCanonicalName() ); return (Trans) new TransEngineAdapter( engine, transMeta ); } ) .orElseThrow( () -> new KettleException( "Unable to find engine [" + transMeta.getVariable( "engine" ) + "]" ) ); } catch ( KettleException e ) { log.logError( "Failed to load engine", e ); throw new RuntimeException( e ); } } } TransSupplier( TransMeta transMeta, LogChannelInterface log, Supplier<Trans> fallbackSupplier ); Trans get(); }### Answer: @Test public void testFallback() throws KettleException { when( fallbackSupplier.get() ).thenReturn( trans ); transSupplier = new TransSupplier( meta, log, fallbackSupplier ); Trans transRet = transSupplier.get(); verify( fallbackSupplier ).get(); assertEquals( transRet, trans ); } @Test public void testWebsocketVersion() throws KettleException { props.setProperty( "KETTLE_AEL_PDI_DAEMON_VERSION", "2.0" ); when( meta.getVariable( "engine" ) ).thenReturn( "spark" ); when( meta.getVariable( "engine.host" ) ).thenReturn( "hostname" ); when( meta.getVariable( "engine.port" ) ).thenReturn( "8080" ); when( meta.nrTransHops() ).thenReturn( 0 ); when( meta.getTransHop( 0 ) ).thenReturn( transHopMeta ); when( meta.realClone( false ) ).thenReturn( meta ); when( transHopMeta.isEnabled() ).thenReturn( false ); transSupplier = new TransSupplier( meta, log, fallbackSupplier ); Trans transRet = transSupplier.get(); assertTrue( transRet instanceof TransWebSocketEngineAdapter ); } @Test( expected = RuntimeException.class ) public void testInvalidEngine() throws KettleException { props.setProperty( "KETTLE_AEL_PDI_DAEMON_VERSION", "1.0" ); when( meta.getVariable( "engine" ) ).thenReturn( "invalidEngine" ); transSupplier = new TransSupplier( meta, log, fallbackSupplier ); transSupplier.get(); }
### Question: GetRootServlet extends BaseHttpServlet implements CartePluginInterface { public void doGet( HttpServletRequest request, HttpServletResponse response ) throws ServletException, IOException { if ( isJettyMode() && !request.getRequestURI().equals( CONTEXT_PATH ) ) { response.setStatus( HttpServletResponse.SC_NOT_FOUND ); return; } if ( log.isDebug() ) { logDebug( BaseMessages.getString( PKG, "GetRootServlet.RootRequested" ) ); } response.setContentType( "text/html;charset=UTF-8" ); response.setStatus( HttpServletResponse.SC_OK ); PrintWriter out = response.getWriter(); out.println( "<HTML>" ); out.println( "<HEAD><TITLE>" + BaseMessages.getString( PKG, "GetRootServlet.KettleSlaveServer.Title" ) + "</TITLE>" ); out.println( "<META http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">" ); out.println( "</HEAD>" ); out.println( "<BODY>" ); out.println( "<H2>" + BaseMessages.getString( PKG, "GetRootServlet.SlaveServerMenu" ) + "</H2>" ); out.println( "<p>" ); out.println( "<a href=\"" + convertContextPath( GetStatusServlet.CONTEXT_PATH ) + "\">" + BaseMessages.getString( PKG, "GetRootServlet.ShowStatus" ) + "</a><br>" ); out.println( "<p>" ); out.println( "</BODY>" ); out.println( "</HTML>" ); } GetRootServlet(); void doGet( HttpServletRequest request, HttpServletResponse response ); String toString(); String getService(); String getContextPath(); static final String CONTEXT_PATH; }### Answer: @Test public void testDoGetReturn404StatusCode() throws ServletException, IOException { GetRootServlet servlet = new GetRootServlet(); servlet.setJettyMode( true ); HttpServletRequest request = when( mock( HttpServletRequest.class ).getRequestURI() ).thenReturn( "/wrong_path" ).getMock(); HttpServletResponse response = mock( HttpServletResponse.class ); servlet.doGet( request, response ); verify( response ).setStatus( HttpServletResponse.SC_NOT_FOUND ); }
### 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 CompressionProvider createCompressionProviderInstance( String name ) { CompressionProvider provider = null; List<PluginInterface> providers = getPlugins(); if ( providers != null ) { for ( PluginInterface plugin : providers ) { if ( name != null && name.equalsIgnoreCase( plugin.getName() ) ) { try { return PluginRegistry.getInstance().loadClass( plugin, CompressionProvider.class ); } catch ( Exception e ) { provider = null; } } } } return provider; } 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 testCreateCoreProviders() { CompressionProvider provider = factory.createCompressionProviderInstance( "None" ); assertNotNull( provider ); assertTrue( provider.getClass().isAssignableFrom( NoneCompressionProvider.class ) ); assertEquals( "None", provider.getName() ); assertEquals( "No compression", provider.getDescription() ); provider = factory.createCompressionProviderInstance( "Zip" ); assertNotNull( provider ); assertTrue( provider.getClass().isAssignableFrom( ZIPCompressionProvider.class ) ); assertEquals( "Zip", provider.getName() ); assertEquals( "ZIP compression", provider.getDescription() ); provider = factory.createCompressionProviderInstance( "GZip" ); assertNotNull( provider ); assertTrue( provider.getClass().isAssignableFrom( GZIPCompressionProvider.class ) ); assertEquals( "GZip", provider.getName() ); assertEquals( "GZIP compression", provider.getDescription() ); provider = factory.createCompressionProviderInstance( "Snappy" ); assertNotNull( provider ); assertTrue( provider.getClass().isAssignableFrom( SnappyCompressionProvider.class ) ); assertEquals( "Snappy", provider.getName() ); assertEquals( "Snappy compression", provider.getDescription() ); provider = factory.createCompressionProviderInstance( "Hadoop-snappy" ); assertNotNull( provider ); assertTrue( provider.getClass().isAssignableFrom( HadoopSnappyCompressionProvider.class ) ); assertEquals( "Hadoop-snappy", provider.getName() ); assertEquals( "Hadoop Snappy compression", provider.getDescription() ); }
### 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: Messages { public static String getString( String key ) { try { return RESOURCE_BUNDLE.getString( key ); } catch ( MissingResourceException e ) { return '!' + key + '!'; } } private Messages(); static ResourceBundle getBundle(); static String getString( String key ); static String getString( String key, String param1 ); static String getString( String key, String param1, String param2 ); static String getString( String key, String param1, String param2, String param3 ); static String getString( String key, String param1, String param2, String param3, String param4 ); }### Answer: @Test public void testGetString() throws Exception { assertEquals( "Database Connection", Messages.getString( "DatabaseDialog.Shell.title" ) ); assertEquals( "!Not.A.Message!", Messages.getString( "Not.A.Message" ) ); assertEquals( "MyParam: JDBC options help", Messages.getString( "DatabaseDialog.JDBCOptions.Tab", "MyParam" ) ); assertEquals( "!Not.A.Message!", Messages.getString( "Not.A.Message", "Unused1" ) ); assertEquals( "!null!", Messages.getString( null, "Unused1" ) ); assertEquals( "MyParam: JDBC options help", Messages.getString( "DatabaseDialog.JDBCOptions.Tab", "MyParam", "Unused" ) ); assertEquals( "!Not.A.Message!", Messages.getString( "Not.A.Message", "Unused1", "Unused2" ) ); assertEquals( "!null!", Messages.getString( null, null, null ) ); assertEquals( "MyParam: JDBC options help", Messages.getString( "DatabaseDialog.JDBCOptions.Tab", "MyParam", "Unused2", "Unused3" ) ); assertEquals( "!Not.A.Message!", Messages.getString( "Not.A.Message", "Unused1", "Unused2", "Unused3" ) ); assertEquals( "!null!", Messages.getString( null, null, null, null ) ); assertEquals( "MyParam: JDBC options help", Messages.getString( "DatabaseDialog.JDBCOptions.Tab", "MyParam", "Unused2", "Unused3", "Unused4" ) ); assertEquals( "!Not.A.Message!", Messages.getString( "Not.A.Message", "Unused1", "Unused2", "Unused3", "Unused4" ) ); assertEquals( "!null!", Messages.getString( null, null, null, null, null ) ); }
### 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 Number jsToNumber( Object value, String classType ) { if ( classType.equalsIgnoreCase( "org.mozilla.javascript.Undefined" ) ) { return null; } else if ( classType.equalsIgnoreCase( "org.mozilla.javascript.NativeJavaObject" ) ) { try { Value v = (Value) Context.jsToJava( value, Value.class ); return v.getNumber(); } catch ( Exception e ) { String string = Context.toString( value ); return Double.parseDouble( Const.trim( string ) ); } } else if ( classType.equalsIgnoreCase( "org.mozilla.javascript.NativeNumber" ) ) { Number nb = Context.toNumber( value ); return nb.doubleValue(); } else { Number nb = (Number) value; return nb.doubleValue(); } } 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 jsToNumber_Undefined() throws Exception { assertNull( JavaScriptUtils.jsToNumber( null, UNDEFINED ) ); } @Test public void jsToNumber_NativeJavaObject_Double() throws Exception { Scriptable value = getDoubleValue(); Number number = JavaScriptUtils.jsToNumber( value, JAVA_OBJECT ); assertEquals( 1.0, number.doubleValue(), 1e-6 ); } @Test public void jsToNumber_NativeJavaObject_Int() throws Exception { Scriptable value = getIntValue(); Number number = JavaScriptUtils.jsToNumber( value, JAVA_OBJECT ); assertEquals( 1.0, number.doubleValue(), 1e-6 ); } @Test public void jsToNumber_NativeNumber() throws Exception { Scriptable value = Context.toObject( 1.0, scope ); Number number = JavaScriptUtils.jsToNumber( value, NATIVE_NUMBER ); assertEquals( 1.0, number.doubleValue(), 1e-6 ); } @Test public void jsToNumber_JavaNumber() throws Exception { Number number = JavaScriptUtils.jsToNumber( 1.0, Double.class.getName() ); assertEquals( 1.0, number.doubleValue(), 1e-6 ); }
### Question: JavaScriptUtils { public static Long jsToInteger( Object value, Class<?> clazz ) { if ( Number.class.isAssignableFrom( clazz ) ) { return ( (Number) value ).longValue(); } else { String classType = clazz.getName(); if ( classType.equalsIgnoreCase( "java.lang.String" ) ) { return ( new Long( (String) value ) ); } else if ( classType.equalsIgnoreCase( "org.mozilla.javascript.Undefined" ) ) { return null; } else if ( classType.equalsIgnoreCase( "org.mozilla.javascript.NativeNumber" ) ) { Number nb = Context.toNumber( value ); return nb.longValue(); } else if ( classType.equalsIgnoreCase( "org.mozilla.javascript.NativeJavaObject" ) ) { try { Value v = (Value) Context.jsToJava( value, Value.class ); return v.getInteger(); } catch ( Exception e2 ) { String string = Context.toString( value ); return Long.parseLong( Const.trim( string ) ); } } else { return Long.parseLong( value.toString() ); } } } 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 jsToInteger_Undefined() throws Exception { assertNull( JavaScriptUtils.jsToInteger( null, Undefined.class ) ); } @Test public void jsToInteger_NaturalNumbers() throws Exception { Number[] naturalNumbers = new Number[] { (byte) 1, (short) 1, 1, (long) 1 }; for ( Number number : naturalNumbers ) { assertEquals( Long.valueOf( 1 ), JavaScriptUtils.jsToInteger( number, number.getClass() ) ); } } @Test public void jsToInteger_String() throws Exception { assertEquals( Long.valueOf( 1 ), JavaScriptUtils.jsToInteger( "1", String.class ) ); } @Test( expected = NumberFormatException.class ) public void jsToInteger_String_Unparseable() throws Exception { JavaScriptUtils.jsToInteger( "q", String.class ); } @Test public void jsToInteger_Double() throws Exception { assertEquals( Long.valueOf( 1 ), JavaScriptUtils.jsToInteger( 1.0, Double.class ) ); } @Test public void jsToInteger_NativeJavaObject_Int() throws Exception { Scriptable value = getIntValue(); assertEquals( Long.valueOf( 1 ), JavaScriptUtils.jsToInteger( value, NativeJavaObject.class ) ); } @Test public void jsToInteger_NativeJavaObject_Double() throws Exception { Scriptable value = getDoubleValue(); assertEquals( Long.valueOf( 1 ), JavaScriptUtils.jsToInteger( value, NativeJavaObject.class ) ); } @Test public void jsToInteger_Other_Int() throws Exception { assertEquals( Long.valueOf( 1 ), JavaScriptUtils.jsToInteger( 1, getClass() ) ); } @Test( expected = NumberFormatException.class ) public void jsToInteger_Other_String() throws Exception { JavaScriptUtils.jsToInteger( "qwerty", getClass() ); }
### 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: JavaScriptUtils { public static Date jsToDate( Object value, String classType ) throws KettleValueException { double dbl; if ( classType.equalsIgnoreCase( "org.mozilla.javascript.Undefined" ) ) { return null; } else { if ( classType.equalsIgnoreCase( "org.mozilla.javascript.NativeDate" ) ) { dbl = Context.toNumber( value ); } else if ( classType.equalsIgnoreCase( "org.mozilla.javascript.NativeJavaObject" ) \|\| classType.equalsIgnoreCase( "java.util.Date" ) ) { try { Date dat = (Date) Context.jsToJava( value, java.util.Date.class ); dbl = dat.getTime(); } catch ( Exception e ) { try { Value v = (Value) Context.jsToJava( value, Value.class ); return v.getDate(); } catch ( Exception e2 ) { try { String string = Context.toString( value ); return XMLHandler.stringToDate( string ); } catch ( Exception e3 ) { throw new KettleValueException( "Can't convert a string to a date" ); } } } } else if ( classType.equalsIgnoreCase( "java.lang.Double" ) ) { dbl = (Double) value; } else { String string = (String) Context.jsToJava( value, String.class ); dbl = Double.parseDouble( string ); } long lng = Math.round( dbl ); return new Date( lng ); } } 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 jsToDate_Undefined() throws Exception { assertNull( JavaScriptUtils.jsToDate( null, UNDEFINED ) ); } @Test public void jsToDate_NativeDate() throws Exception { Date date = new Date( 1 ); Scriptable value = ctx.newObject( scope, "Date", new Object[] { date.getTime() } ); assertEquals( date, JavaScriptUtils.jsToDate( value, "org.mozilla.javascript.NativeDate" ) ); } @Test public void jsToDate_NativeJavaObject() throws Exception { Scriptable value = getIntValue(); assertEquals( new Date( 1 ), JavaScriptUtils.jsToDate( value, JAVA_OBJECT ) ); } @Test public void jsToDate_Double() throws Exception { assertEquals( new Date( 1 ), JavaScriptUtils.jsToDate( 1.0, Double.class.getName() ) ); } @Test public void jsToDate_String() throws Exception { assertEquals( new Date( 1 ), JavaScriptUtils.jsToDate( "1.0", String.class.getName() ) ); } @Test( expected = NumberFormatException.class ) public void jsToDate_String_Unparseable() throws Exception { JavaScriptUtils.jsToDate( "qwerty", String.class.getName() ); }
### Question: JavaScriptUtils { public static Object convertFromJs( Object value, int type, String fieldName ) throws KettleValueException { String classType = value.getClass().getName(); switch ( type ) { case ValueMetaInterface.TYPE_NUMBER: return jsToNumber( value, classType ); case ValueMetaInterface.TYPE_INTEGER: return jsToInteger( value, value.getClass() ); case ValueMetaInterface.TYPE_STRING: return jsToString( value, classType ); case ValueMetaInterface.TYPE_DATE: return jsToDate( value, classType ); case ValueMetaInterface.TYPE_BOOLEAN: return value; case ValueMetaInterface.TYPE_BIGNUMBER: return jsToBigNumber( value, classType ); case ValueMetaInterface.TYPE_BINARY: { return Context.jsToJava( value, byte[].class ); } case ValueMetaInterface.TYPE_NONE: { throw new RuntimeException( "No data output data type was specified for new field [" + fieldName + "]" ); } default: return Context.jsToJava( value, Object.class ); } } 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( expected = RuntimeException.class ) public void convertFromJs_TypeNone() throws Exception { JavaScriptUtils.convertFromJs( null, ValueMetaInterface.TYPE_NONE, "qwerty" ); } @Test public void convertFromJs_TypeBoolean() throws Exception { Object o = new Object(); Object o2 = JavaScriptUtils.convertFromJs( o, ValueMetaInterface.TYPE_BOOLEAN, "qwerty" ); assertEquals( o, o2 ); } @Test public void convertFromJs_TypeBinary() throws Exception { byte[] bytes = new byte[] { 0, 1 }; Object converted = JavaScriptUtils.convertFromJs( bytes, ValueMetaInterface.TYPE_BINARY, "qwerty" ); assertThat( converted, is( instanceOf( byte[].class ) ) ); assertArrayEquals( bytes, (byte[]) converted ); }
### Question: ConfigurableStreamLogger implements Runnable { public void run() { try { InputStreamReader isr = new InputStreamReader( this.is ); BufferedReader br = new BufferedReader( isr ); String line = null; while ( ( line = br.readLine() ) != null ) { String logEntry = this.type + " " + line; switch ( this.logLevel ) { case MINIMAL: log.logMinimal( logEntry ); break; case BASIC: log.logBasic( logEntry ); break; case DETAILED: log.logDetailed( logEntry ); break; case DEBUG: log.logDebug( logEntry ); break; case ROWLEVEL: log.logRowlevel( logEntry ); break; case ERROR: log.logError( logEntry ); break; default: break; } } } catch ( IOException ioe ) { if ( log.isError() ) { log.logError( this.type + " " + Const.getStackTracker( ioe ) ); } } } ConfigurableStreamLogger( LogChannelInterface logChannel, final InputStream in, final LogLevel logLevel, final String type ); void run(); }### Answer: @Test public void testLogError() { streamLogger = new ConfigurableStreamLogger( log, is, LogLevel.ERROR, PREFIX ); streamLogger.run(); Mockito.verify( log ).logError( OUT1 ); Mockito.verify( log ).logError( OUT2 ); } @Test public void testLogMinimal() { streamLogger = new ConfigurableStreamLogger( log, is, LogLevel.MINIMAL, PREFIX ); streamLogger.run(); Mockito.verify( log ).logMinimal( OUT1 ); Mockito.verify( log ).logMinimal( OUT2 ); } @Test public void testLogBasic() { streamLogger = new ConfigurableStreamLogger( log, is, LogLevel.BASIC, PREFIX ); streamLogger.run(); Mockito.verify( log ).logBasic( OUT1 ); Mockito.verify( log ).logBasic( OUT2 ); } @Test public void testLogDetailed() { streamLogger = new ConfigurableStreamLogger( log, is, LogLevel.DETAILED, PREFIX ); streamLogger.run(); Mockito.verify( log ).logDetailed( OUT1 ); Mockito.verify( log ).logDetailed( OUT2 ); } @Test public void testLogDebug() { streamLogger = new ConfigurableStreamLogger( log, is, LogLevel.DEBUG, PREFIX ); streamLogger.run(); Mockito.verify( log ).logDebug( OUT1 ); Mockito.verify( log ).logDebug( OUT2 ); } @Test public void testLogRowlevel() { streamLogger = new ConfigurableStreamLogger( log, is, LogLevel.ROWLEVEL, PREFIX ); streamLogger.run(); Mockito.verify( log ).logRowlevel( OUT1 ); Mockito.verify( log ).logRowlevel( OUT2 ); }
### 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: LogChannelFileWriter { public synchronized void flush() { try { StringBuffer buffer = this.buffer.getBuffer(); logFileOutputStream.write( buffer.toString().getBytes() ); logFileOutputStream.flush(); } catch ( Exception e ) { exception = new KettleException( "There was an error logging to file '" + logFile + "'", e ); } } LogChannelFileWriter( String logChannelId, FileObject logFile, boolean appending, int pollingInterval ); LogChannelFileWriter( String logChannelId, FileObject logFile, boolean appending ); void startLogging(); synchronized void flush(); void stopLogging(); KettleException getException(); String getLogChannelId(); void setLogChannelId( String logChannelId ); FileObject getLogFile(); void setLogFile( FileObject logFile ); boolean isAppending(); void setAppending( boolean appending ); int getPollingInterval(); void setPollingInterval( int pollingInterval ); }### Answer: @Test public void test() throws Exception { String id = "1"; String logMessage = "Log message"; FileObject fileObject = mock( FileObject.class ); FileContent fileContent = mock( FileContent.class ); OutputStream outputStream = mock( OutputStream.class ); when( fileObject.getContent() ).thenReturn( fileContent ); when( fileContent.getOutputStream( anyBoolean() ) ).thenReturn( outputStream ); LogChannelFileWriter writer = new LogChannelFileWriter( id, fileObject, false ); LoggingRegistry.getInstance().getLogChannelFileWriterBuffer( id ).addEvent( new KettleLoggingEvent( logMessage, System.currentTimeMillis(), LogLevel.BASIC ) ); writer.flush(); ArgumentCaptor<byte[]> captor = ArgumentCaptor.forClass( byte[].class ); verify( outputStream ).write( captor.capture() ); String arguments = new String( captor.getValue() ); assertTrue( arguments.contains( logMessage ) ); } @Test public void test() throws Exception { LogChannelFileWriter writer = new LogChannelFileWriter( id, fileObject, false ); LoggingRegistry.getInstance().getLogChannelFileWriterBuffer( id ).addEvent( new KettleLoggingEvent( logMessage, System.currentTimeMillis(), LogLevel.BASIC ) ); writer.flush(); verify( outputStream ).write( captor.capture() ); String arguments = new String( captor.getValue() ); assertTrue( arguments.contains( logMessage ) ); }
### Question: JobTracker { public void addJobTracker( JobTracker jobTracker ) { lock.writeLock().lock(); try { jobTrackers.add( jobTracker ); while ( jobTrackers.size() > maxChildren ) { jobTrackers.removeFirst(); } } finally { lock.writeLock().unlock(); } } JobTracker( JobMeta jobMeta ); JobTracker( JobMeta jobMeta, int maxChildren ); JobTracker( JobMeta jobMeta, JobEntryResult result ); JobTracker( JobMeta jobMeta, int maxChildren, JobEntryResult result ); void addJobTracker( JobTracker jobTracker ); JobTracker getJobTracker( int i ); int nrJobTrackers(); List<JobTracker> getJobTrackers(); void setJobTrackers( List<JobTracker> jobTrackers ); JobEntryResult getJobEntryResult(); void setJobEntryResult( JobEntryResult result ); void clear(); JobTracker findJobTracker( JobEntryCopy jobEntryCopy ); JobTracker getParentJobTracker(); void setParentJobTracker( JobTracker parentJobTracker ); int getTotalNumberOfItems(); String getJobFilename(); void setJobFilename( String jobFilename ); String getJobName(); void setJobName( String jobName ); int getMaxChildren(); void setMaxChildren( int maxChildren ); }### Answer: @Test public void testAddJobTracker() throws Exception { final String old = System.getProperty( Const.KETTLE_MAX_JOB_TRACKER_SIZE ); final Integer maxTestSize = 30; try { System.setProperty( Const.KETTLE_MAX_JOB_TRACKER_SIZE, maxTestSize.toString() ); JobMeta jobMeta = mock( JobMeta.class ); JobTracker jobTracker = new JobTracker( jobMeta ); for ( int n = 0; n < maxTestSize * 2; n++ ) { jobTracker.addJobTracker( mock( JobTracker.class ) ); } assertTrue( "More JobTrackers than allowed were added", jobTracker.getTotalNumberOfItems() <= maxTestSize ); } finally { if ( old == null ) { System.clearProperty( Const.KETTLE_MAX_JOB_TRACKER_SIZE ); } else { System.setProperty( Const.KETTLE_MAX_JOB_TRACKER_SIZE, old ); } } }
### Question: AuthenticationManager { public <ReturnType, CreateArgType, ConsumedType> void registerConsumerFactory( AuthenticationConsumerFactory<ReturnType, CreateArgType, ConsumedType> factory ) throws AuthenticationFactoryException { if ( !factory.getConsumedType().isInterface() && !AuthenticationProvider.class.isAssignableFrom( factory.getConsumedType() ) ) { throw new AuthenticationFactoryException( BaseMessages.getString( PKG, "AuthenticationManager.ConsumedTypeError", factory ) ); } Map<Class<?>, AuthenticationConsumerFactory<?, ?, ?>> createTypeMap = getRelevantConsumerFactoryMap( factory.getReturnType(), factory.getCreateArgType() ); synchronized ( createTypeMap ) { createTypeMap.put( factory.getConsumedType(), factory ); } } void registerAuthenticationProvider( AuthenticationProvider authenticationProvider ); boolean unregisterAuthenticationProvider( AuthenticationProvider authenticationProvider ); void registerConsumerFactory( AuthenticationConsumerFactory<ReturnType, CreateArgType, ConsumedType> factory ); void registerConsumerClass( Class<? extends AuthenticationConsumer<? extends ReturnType, ? extends ConsumedType>> consumerClass ); List<AuthenticationPerformer<ReturnType, CreateArgType>> getSupportedAuthenticationPerformers( Class<ReturnType> returnType, Class<CreateArgType> createArgType ); AuthenticationPerformer<ReturnType, CreateArgType> getAuthenticationPerformer( Class<ReturnType> returnType, Class<CreateArgType> createArgType, String providerId ); }### Answer: @SuppressWarnings( { "rawtypes", "unchecked" } ) @Test public void testRegisterConsumerFactory() throws AuthenticationConsumptionException, AuthenticationFactoryException { AuthenticationConsumer<Object, KerberosAuthenticationProvider> authConsumer = mock( AuthenticationConsumer.class ); AuthenticationConsumerFactory<Object, AuthenticationConsumer, KerberosAuthenticationProvider> factory = mock( AuthenticationConsumerFactory.class ); when( factory.getReturnType() ).thenReturn( Object.class ); when( factory.getCreateArgType() ).thenReturn( AuthenticationConsumer.class ); when( factory.getConsumedType() ).thenReturn( KerberosAuthenticationProvider.class ); when( factory.create( authConsumer ) ).thenReturn( authConsumer ); KerberosAuthenticationProvider kerberosAuthenticationProvider = new KerberosAuthenticationProvider( "kerb", "kerb", true, "pass", true, "none" ); manager.registerAuthenticationProvider( kerberosAuthenticationProvider ); manager.registerConsumerFactory( factory ); manager.getAuthenticationPerformer( Object.class, AuthenticationConsumer.class, kerberosAuthenticationProvider.getId() ).perform( authConsumer ); verify( authConsumer ).consume( kerberosAuthenticationProvider ); }
### 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: JobExecutionConfiguration implements ExecutionConfiguration { public Long getPassedBatchId() { return passedBatchId; } JobExecutionConfiguration(); JobExecutionConfiguration( Node trecNode ); Object clone(); Map<String, String> getArguments(); void setArguments( Map<String, String> arguments ); void setParams( Map<String, String> params ); Map<String, String> getParams(); void setArgumentStrings( String[] arguments ); Map<String, String> getVariables(); void setVariables( Map<String, String> variables ); void setVariables( VariableSpace space ); boolean isExecutingRemotely(); void setExecutingRemotely( boolean remoteExecution ); boolean isExecutingLocally(); void setExecutingLocally( boolean localExecution ); SlaveServer getRemoteServer(); void setRemoteServer( SlaveServer remoteServer ); void getUsedVariables( JobMeta jobMeta ); Date getReplayDate(); void setReplayDate( Date replayDate ); boolean isSafeModeEnabled(); void setSafeModeEnabled( boolean usingSafeMode ); @Override String getRunConfiguration(); @Override void setRunConfiguration( String runConfiguration ); LogLevel getLogLevel(); void setLogLevel( LogLevel logLevel ); String getXML(); Repository connectRepository( String repositoryName, String username, String password ); Repository connectRepository( RepositoriesMeta repositoriesMeta, String repositoryName, String username, String password ); String[] getArgumentStrings(); Result getPreviousResult(); void setPreviousResult( Result previousResult ); Repository getRepository(); void setRepository( Repository repository ); boolean isClearingLog(); void setClearingLog( boolean clearingLog ); boolean isPassingExport(); void setPassingExport( boolean passingExport ); String getStartCopyName(); void setStartCopyName( String startCopyName ); int getStartCopyNr(); void setStartCopyNr( int startCopyNr ); boolean isGatheringMetrics(); void setGatheringMetrics( boolean gatheringMetrics ); void setExpandingRemoteJob( boolean expandingRemoteJob ); boolean isExpandingRemoteJob(); Map<String, String> getExtensionOptions(); void setExtensionOptions( Map<String, String> extensionOptions ); Long getPassedBatchId(); void setPassedBatchId( Long passedBatchId ); void getUsedArguments( JobMeta jobMeta, String[] commandLineArguments, IMetaStore metaStore ); static final String XML_TAG; }### Answer: @Test public void testDefaultPassedBatchId() { JobExecutionConfiguration jec = new JobExecutionConfiguration(); assertEquals( "default passedBatchId value must be null", null, jec.getPassedBatchId() ); }
### Question: JobEntryShell extends JobEntryBase implements Cloneable, JobEntryInterface { @VisibleForTesting String replaceWinEOL( String input ) { String result = input; result = result.replaceAll( "\\r\\n?", "\n" ); return result; } JobEntryShell( String name ); JobEntryShell(); void allocate( int nrFields ); Object clone(); String getXML(); void loadXML( Node entrynode, List<DatabaseMeta> databases, List<SlaveServer> slaveServers, Repository rep, IMetaStore metaStore ); void loadRep( Repository rep, IMetaStore metaStore, ObjectId id_jobentry, List<DatabaseMeta> databases, List<SlaveServer> slaveServers ); void saveRep( Repository rep, IMetaStore metaStore, ObjectId id_job ); void clear(); @Deprecated void setFileName( String n ); void setFilename( String n ); String getFilename(); String getRealFilename(); void setWorkDirectory( String n ); String getWorkDirectory(); void setScript( String scriptin ); String getScript(); String getLogFilename(); Result execute( Result result, int nr ); boolean evaluates(); boolean isUnconditional(); List<ResourceReference> getResourceDependencies( JobMeta jobMeta ); @Override void check( List<CheckResultInterface> remarks, JobMeta jobMeta, VariableSpace space, Repository repository, IMetaStore metaStore ); public String[] arguments; public boolean argFromPrevious; public boolean setLogfile; public String logfile; public boolean addDate; public LogLevel logFileLevel; public boolean execPerRow; public boolean setAppendLogfile; public boolean insertScript; public String script; }### Answer: @Test public void replaceWinEOLtest() { String content = "#!/bin/bash\r\n" + "\r\n" + "echo `date` > /home/pentaho/test_output/output.txt"; doCallRealMethod().when( jobEntryShellMock ).replaceWinEOL( anyString() ); content = jobEntryShellMock.replaceWinEOL( content ); verify( jobEntryShellMock ).replaceWinEOL( anyString() ); String assertionFailedMessage = "Windows EOL character is detected"; Assert.assertFalse( assertionFailedMessage, content.contains( "\r\n" ) ); Assert.assertFalse( assertionFailedMessage, content.contains( "\r" ) ); }

Subsets and Splits

No saved queries yet

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