method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
Log4jKettleLayout extends Layout implements Log4JLayoutInterface { public String format( LoggingEvent event ) { StringBuffer line = new StringBuffer(); String dateTimeString = ""; if ( timeAdded ) { dateTimeString = LOCAL_SIMPLE_DATE_PARSER.get().format( new Date( event.timeStamp ) ) + " - "; } Object object = event.getMessage(); if ( object instanceof LogMessage ) { LogMessage message = (LogMessage) object; String[] parts = message.getMessage().split( Const.CR ); for ( int i = 0; i < parts.length; i++ ) { line.append( dateTimeString ); if ( message.getSubject() != null ) { line.append( message.getSubject() ); if ( message.getCopy() != null ) { line.append( "." ).append( message.getCopy() ); } line.append( " - " ); } if ( message.isError() ) { BuildVersion buildVersion = BuildVersion.getInstance(); line.append( ERROR_STRING ); line.append( " (version " ); line.append( buildVersion.getVersion() ); if ( !Utils.isEmpty( buildVersion.getRevision() ) ) { line.append( ", build " ); line.append( buildVersion.getRevision() ); } if ( !Utils.isEmpty( buildVersion.getBuildDate() ) ) { line.append( " from " ); line.append( buildVersion.getBuildDate() ); } if ( !Utils.isEmpty( buildVersion.getBuildUser() ) ) { line.append( " by " ); line.append( buildVersion.getBuildUser() ); } line.append( ") : " ); } line.append( parts[i] ); if ( i < parts.length - 1 ) { line.append( Const.CR ); } } } else { line.append( dateTimeString ); line.append( ( object != null ? object.toString() : "<null>" ) ); } return line.toString(); } Log4jKettleLayout(); Log4jKettleLayout( boolean addTime ); String format( LoggingEvent event ); boolean ignoresThrowable(); void activateOptions(); boolean isTimeAdded(); void setTimeAdded( boolean addTime ); static final String ERROR_STRING; }### Answer:
@Test public void formatNonLogMessage_without_add_time() { Log4jKettleLayout layout = new Log4jKettleLayout( false ); String actualResult = layout.format( mock( LoggingEvent.class ) ); assertThat( actualResult, equalTo( "<null>" ) ); }
@Test public void formatNonLogMessage_with_add_time() { Log4jKettleLayout layout = new Log4jKettleLayout( true ); String actualResult = layout.format( mock( LoggingEvent.class ) ); assertThat( actualResult, equalTo( "1970/01/01 00:00:00 - <null>" ) ); }
@Test public void formatLogMessage_without_add_time() { Log4jKettleLayout layout = new Log4jKettleLayout( false ); LoggingEvent loggingEvent = mock( LoggingEvent.class ); LogMessage logMessage = new LogMessage( "TEST_MESSAGE", "TEST_ID", LogLevel.BASIC ); when( loggingEvent.getMessage() ).thenReturn( logMessage ); String actualResult = layout.format( loggingEvent ); assertThat( actualResult, equalTo( "TEST_MESSAGE" ) ); }
@Test public void formatLogMessage_with_add_time() { Log4jKettleLayout layout = new Log4jKettleLayout( true ); LoggingEvent loggingEvent = mock( LoggingEvent.class ); LogMessage logMessage = new LogMessage( "TEST_MESSAGE", "TEST_ID", LogLevel.BASIC ); when( loggingEvent.getMessage() ).thenReturn( logMessage ); String actualResult = layout.format( loggingEvent ); assertThat( actualResult, equalTo( "1970/01/01 00:00:00 - TEST_MESSAGE" ) ); } |
### Question:
Log4jFileAppender implements Appender { public void doAppend( LoggingEvent event ) { String line = layout.format( event ) + Const.CR; try { fileOutputStream.write( line.getBytes( Const.XML_ENCODING ) ); } catch ( IOException e ) { System.out.println( "Unable to close Logging file [" + file.getName() + "] : " + e.getMessage() ); } } Log4jFileAppender( FileObject file ); Log4jFileAppender( FileObject file, boolean append ); void addFilter( Filter filter ); Filter getFilter(); void clearFilters(); void close(); void doAppend( LoggingEvent event ); void setName( String name ); String getName(); void setErrorHandler( ErrorHandler arg0 ); ErrorHandler getErrorHandler(); void setLayout( Layout layout ); Layout getLayout(); boolean requiresLayout(); FileObject getFile(); void setFilename( FileObject file ); OutputStream getFileOutputStream(); void setFileOutputStream( OutputStream fileOutputStream ); void setFilter( Filter filter ); }### Answer:
@Test public void doAppend() throws IOException { LoggingEvent loggingEvent = mock( LoggingEvent.class ); Layout testLayout = mock( Layout.class ); when( testLayout.format( loggingEvent ) ).thenReturn( "LOG_TEST_LINE" ); log4jFileAppender.setLayout( testLayout ); log4jFileAppender.doAppend( loggingEvent ); verify( outputStream ).write( ( "LOG_TEST_LINE" + Const.CR ).getBytes() ); } |
### Question:
Log4jFileAppender implements Appender { public void close() { try { fileOutputStream.close(); } catch ( IOException e ) { System.out.println( "Unable to close Logging file [" + file.getName() + "] : " + e.getMessage() ); } } Log4jFileAppender( FileObject file ); Log4jFileAppender( FileObject file, boolean append ); void addFilter( Filter filter ); Filter getFilter(); void clearFilters(); void close(); void doAppend( LoggingEvent event ); void setName( String name ); String getName(); void setErrorHandler( ErrorHandler arg0 ); ErrorHandler getErrorHandler(); void setLayout( Layout layout ); Layout getLayout(); boolean requiresLayout(); FileObject getFile(); void setFilename( FileObject file ); OutputStream getFileOutputStream(); void setFileOutputStream( OutputStream fileOutputStream ); void setFilter( Filter filter ); }### Answer:
@Test public void close() throws IOException { log4jFileAppender.close(); verify( outputStream ).close(); } |
### Question:
ElasticSearchBulkMeta extends BaseStepMeta implements StepMetaInterface { public int getBatchSizeInt( VariableSpace vars ) { return Const.toInt( vars.environmentSubstitute( this.batchSize ), DEFAULT_BATCH_SIZE ); } ElasticSearchBulkMeta(); String getJsonField(); void setJsonField( String jsonField ); String getIdOutField(); void setIdOutField( String idField ); boolean isJsonInsert(); void setJsonInsert( boolean isJsonInsert ); String getIndex(); void setIndex( String index ); String getType(); void setType( String type ); void setIdInField( String idInField ); String getIdInField(); void setOverWriteIfSameId( boolean overWriteIfSameId ); boolean isOverWriteIfSameId(); boolean isUseOutput(); void setUseOutput( boolean value ); boolean isStopOnError(); void setStopOnError( boolean stopOnError ); List<Field> getFields(); Map<String, String> getFieldsMap(); void setFieldsMap( Map<String, String> values ); void clearFields(); void addField( String inputName, String nameInJson ); List<Server> getServers(); void setServers( List<Server> values ); void clearServers(); void addServer( String addr, int port ); Map<String, String> getSettingsMap(); void setSettingsMap( Map<String, String> values ); void clearSettings(); void addSetting( String property, String value ); void setBatchSize( String value ); String getBatchSize(); int getBatchSizeInt( VariableSpace vars ); String getTimeOut(); void setTimeOut( String TimeOut ); TimeUnit getTimeoutUnit(); void setTimeoutUnit( TimeUnit timeoutUnit ); Object clone(); void setDefault(); void getFields( RowMetaInterface r, String name, RowMetaInterface[] info, StepMeta nextStep,
VariableSpace space, Repository repository, IMetaStore metaStore ); void loadXML( Node stepnode, List<DatabaseMeta> databases, 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(); boolean supportsErrorHandling(); static final int DEFAULT_BATCH_SIZE; static final Long DEFAULT_TIMEOUT; static final TimeUnit DEFAULT_TIMEOUT_UNIT; static final int DEFAULT_PORT; }### Answer:
@Test public void testGetBatchSizeInt() { ElasticSearchBulkMeta esbm = new ElasticSearchBulkMeta(); int batchSize = esbm.getBatchSizeInt( new VariableSpaceImpl() ); assertEquals( batchSize, ElasticSearchBulkMeta.DEFAULT_BATCH_SIZE ); } |
### Question:
ElasticSearchBulkMeta extends BaseStepMeta implements StepMetaInterface { public Object clone() { ElasticSearchBulkMeta retval = (ElasticSearchBulkMeta) super.clone(); return retval; } ElasticSearchBulkMeta(); String getJsonField(); void setJsonField( String jsonField ); String getIdOutField(); void setIdOutField( String idField ); boolean isJsonInsert(); void setJsonInsert( boolean isJsonInsert ); String getIndex(); void setIndex( String index ); String getType(); void setType( String type ); void setIdInField( String idInField ); String getIdInField(); void setOverWriteIfSameId( boolean overWriteIfSameId ); boolean isOverWriteIfSameId(); boolean isUseOutput(); void setUseOutput( boolean value ); boolean isStopOnError(); void setStopOnError( boolean stopOnError ); List<Field> getFields(); Map<String, String> getFieldsMap(); void setFieldsMap( Map<String, String> values ); void clearFields(); void addField( String inputName, String nameInJson ); List<Server> getServers(); void setServers( List<Server> values ); void clearServers(); void addServer( String addr, int port ); Map<String, String> getSettingsMap(); void setSettingsMap( Map<String, String> values ); void clearSettings(); void addSetting( String property, String value ); void setBatchSize( String value ); String getBatchSize(); int getBatchSizeInt( VariableSpace vars ); String getTimeOut(); void setTimeOut( String TimeOut ); TimeUnit getTimeoutUnit(); void setTimeoutUnit( TimeUnit timeoutUnit ); Object clone(); void setDefault(); void getFields( RowMetaInterface r, String name, RowMetaInterface[] info, StepMeta nextStep,
VariableSpace space, Repository repository, IMetaStore metaStore ); void loadXML( Node stepnode, List<DatabaseMeta> databases, 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(); boolean supportsErrorHandling(); static final int DEFAULT_BATCH_SIZE; static final Long DEFAULT_TIMEOUT; static final TimeUnit DEFAULT_TIMEOUT_UNIT; static final int DEFAULT_PORT; }### Answer:
@Test public void testClone() { ElasticSearchBulkMeta esbm = new ElasticSearchBulkMeta(); ElasticSearchBulkMeta esbmClone = (ElasticSearchBulkMeta) esbm.clone(); assertNotNull( esbmClone ); } |
### Question:
ElasticSearchBulkMeta extends BaseStepMeta implements StepMetaInterface { public boolean supportsErrorHandling() { return true; } ElasticSearchBulkMeta(); String getJsonField(); void setJsonField( String jsonField ); String getIdOutField(); void setIdOutField( String idField ); boolean isJsonInsert(); void setJsonInsert( boolean isJsonInsert ); String getIndex(); void setIndex( String index ); String getType(); void setType( String type ); void setIdInField( String idInField ); String getIdInField(); void setOverWriteIfSameId( boolean overWriteIfSameId ); boolean isOverWriteIfSameId(); boolean isUseOutput(); void setUseOutput( boolean value ); boolean isStopOnError(); void setStopOnError( boolean stopOnError ); List<Field> getFields(); Map<String, String> getFieldsMap(); void setFieldsMap( Map<String, String> values ); void clearFields(); void addField( String inputName, String nameInJson ); List<Server> getServers(); void setServers( List<Server> values ); void clearServers(); void addServer( String addr, int port ); Map<String, String> getSettingsMap(); void setSettingsMap( Map<String, String> values ); void clearSettings(); void addSetting( String property, String value ); void setBatchSize( String value ); String getBatchSize(); int getBatchSizeInt( VariableSpace vars ); String getTimeOut(); void setTimeOut( String TimeOut ); TimeUnit getTimeoutUnit(); void setTimeoutUnit( TimeUnit timeoutUnit ); Object clone(); void setDefault(); void getFields( RowMetaInterface r, String name, RowMetaInterface[] info, StepMeta nextStep,
VariableSpace space, Repository repository, IMetaStore metaStore ); void loadXML( Node stepnode, List<DatabaseMeta> databases, 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(); boolean supportsErrorHandling(); static final int DEFAULT_BATCH_SIZE; static final Long DEFAULT_TIMEOUT; static final TimeUnit DEFAULT_TIMEOUT_UNIT; static final int DEFAULT_PORT; }### Answer:
@Test public void testSupportsErrorHandling() { ElasticSearchBulkMeta esbm = new ElasticSearchBulkMeta(); boolean supportsError = esbm.supportsErrorHandling(); assertTrue( supportsError ); } |
### Question:
ElasticSearchBulkMeta extends BaseStepMeta implements StepMetaInterface { public StepDataInterface getStepData() { return new ElasticSearchBulkData(); } ElasticSearchBulkMeta(); String getJsonField(); void setJsonField( String jsonField ); String getIdOutField(); void setIdOutField( String idField ); boolean isJsonInsert(); void setJsonInsert( boolean isJsonInsert ); String getIndex(); void setIndex( String index ); String getType(); void setType( String type ); void setIdInField( String idInField ); String getIdInField(); void setOverWriteIfSameId( boolean overWriteIfSameId ); boolean isOverWriteIfSameId(); boolean isUseOutput(); void setUseOutput( boolean value ); boolean isStopOnError(); void setStopOnError( boolean stopOnError ); List<Field> getFields(); Map<String, String> getFieldsMap(); void setFieldsMap( Map<String, String> values ); void clearFields(); void addField( String inputName, String nameInJson ); List<Server> getServers(); void setServers( List<Server> values ); void clearServers(); void addServer( String addr, int port ); Map<String, String> getSettingsMap(); void setSettingsMap( Map<String, String> values ); void clearSettings(); void addSetting( String property, String value ); void setBatchSize( String value ); String getBatchSize(); int getBatchSizeInt( VariableSpace vars ); String getTimeOut(); void setTimeOut( String TimeOut ); TimeUnit getTimeoutUnit(); void setTimeoutUnit( TimeUnit timeoutUnit ); Object clone(); void setDefault(); void getFields( RowMetaInterface r, String name, RowMetaInterface[] info, StepMeta nextStep,
VariableSpace space, Repository repository, IMetaStore metaStore ); void loadXML( Node stepnode, List<DatabaseMeta> databases, 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(); boolean supportsErrorHandling(); static final int DEFAULT_BATCH_SIZE; static final Long DEFAULT_TIMEOUT; static final TimeUnit DEFAULT_TIMEOUT_UNIT; static final int DEFAULT_PORT; }### Answer:
@Test public void testGetStepData() { ElasticSearchBulkMeta esbm = new ElasticSearchBulkMeta(); StepDataInterface sdi = esbm.getStepData(); assertTrue( sdi instanceof ElasticSearchBulkData ); } |
### Question:
GlobalMessages extends AbstractMessageHandler { public static ResourceBundle getBundle( String packageName ) throws MissingResourceException { return getBundle( packageName, GlobalMessages.getInstance().getClass() ); } GlobalMessages(); static synchronized MessageHandler getInstance(); static synchronized Locale getLocale(); static synchronized void setLocale( Locale newLocale ); static ResourceBundle getBundle( String packageName ); static ResourceBundle getBundle( String packageName, Class<?> resourceClass ); static ResourceBundle getBundle( Locale locale, String packageName ); static ResourceBundle getBundle( Locale locale, String packageName, Class<?> resourceClass ); @Override String getString( String key ); @Override String getString( String packageName, String key ); @Override String getString( String packageName, String key, String... parameters ); @Override String getString( String packageName, String key, Class<?> resourceClass, String... parameters ); static final String[] localeCodes; static final String[] localeDescr; }### Answer:
@Test public void testGetBundleNewUTF8() throws Exception { res = GlobalMessages.getBundle( Locale.JAPAN, "org/pentaho/di/i18n/messages/test_utf8_messages" ); assertEquals( "環境変数の選択", res.getString( "System.Dialog.SelectEnvironmentVar.Title" ) ); res = GlobalMessages.getBundle( Locale.CHINA, "org/pentaho/di/i18n/messages/test_utf8_messages" ); assertEquals( "选择一个环境变量", res.getString( "System.Dialog.SelectEnvironmentVar.Title" ) ); } |
### Question:
MetaStoreConst { public static IMetaStore openLocalPentahoMetaStore() throws MetaStoreException { return MetaStoreConst.openLocalPentahoMetaStore( true ); } static final String getDefaultPentahoMetaStoreLocation(); static IMetaStore openLocalPentahoMetaStore(); static IMetaStore openLocalPentahoMetaStore( boolean allowCreate ); static final String DB_ATTR_ID_DESCRIPTION; static final String DB_ATTR_ID_PLUGIN_ID; static final String DB_ATTR_ID_ACCESS_TYPE; static final String DB_ATTR_ID_HOSTNAME; static final String DB_ATTR_ID_PORT; static final String DB_ATTR_ID_DATABASE_NAME; static final String DB_ATTR_ID_USERNAME; static final String DB_ATTR_ID_PASSWORD; static final String DB_ATTR_ID_SERVERNAME; static final String DB_ATTR_ID_DATA_TABLESPACE; static final String DB_ATTR_ID_INDEX_TABLESPACE; static boolean disableMetaStore; static final String DB_ATTR_DRIVER_CLASS; static final String DB_ATTR_JDBC_URL; static final String DB_ATTR_ID_ATTRIBUTES; }### Answer:
@Test public void testOpenLocalPentahoMetaStore() throws Exception { MetaStoreConst.disableMetaStore = false; File tempDir = Files.createTempDir(); String tempPath = tempDir.getAbsolutePath(); System.setProperty( Const.PENTAHO_METASTORE_FOLDER, tempPath ); String metaFolder = tempPath + File.separator + XmlUtil.META_FOLDER_NAME; assertNotNull( MetaStoreConst.openLocalPentahoMetaStore() ); assertTrue( ( new File( metaFolder ) ).exists() ); MetaStoreConst.disableMetaStore = true; assertNull( MetaStoreConst.openLocalPentahoMetaStore() ); MetaStoreConst.disableMetaStore = false; assertNotNull( MetaStoreConst.openLocalPentahoMetaStore( false ) ); FileUtils.deleteDirectory( new File( metaFolder ) ); assertNull( MetaStoreConst.openLocalPentahoMetaStore( false ) ); assertFalse( ( new File( metaFolder ) ).exists() ); } |
### Question:
TransExecutionConfiguration implements ExecutionConfiguration { public Long getPassedBatchId() { return passedBatchId; } TransExecutionConfiguration(); TransExecutionConfiguration( 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 ); boolean isExecutingClustered(); void setExecutingClustered( boolean clusteredExecution ); boolean isClusterStarting(); void setClusterStarting( boolean notExecuting ); boolean isClusterShowingTransformation(); void setClusterShowingTransformation( boolean showingTransformations ); Map<String, String> getVariables(); void setVariables( Map<String, String> variables ); void setVariables( VariableSpace space ); boolean isExecutingRemotely(); void setExecutingRemotely( boolean remoteExecution ); boolean isClusterPosting(); void setClusterPosting( boolean clusterPosting ); boolean isExecutingLocally(); void setExecutingLocally( boolean localExecution ); boolean isClusterPreparing(); void setClusterPreparing( boolean clusterPreparing ); SlaveServer getRemoteServer(); void setRemoteServer( SlaveServer remoteServer ); void getAllVariables( TransMeta transMeta ); void getUsedVariables( TransMeta transMeta ); void getUsedArguments( TransMeta transMeta, String[] commandLineArguments ); Date getReplayDate(); void setReplayDate( Date replayDate ); boolean isSafeModeEnabled(); void setSafeModeEnabled( boolean usingSafeMode ); LogLevel getLogLevel(); void setLogLevel( LogLevel logLevel ); String getXML(); Repository connectRepository( RepositoriesMeta repositoriesMeta, String repositoryName, String username, String password ); String[] getArgumentStrings(); TransDebugMeta getTransDebugMeta(); void setTransDebugMeta( TransDebugMeta transDebugMeta ); Result getPreviousResult(); void setPreviousResult( Result previousResult ); Repository getRepository(); void setRepository( Repository repository ); boolean isClearingLog(); void setClearingLog( boolean clearingLog ); boolean isPassingExport(); void setPassingExport( boolean passingExport ); boolean isGatheringMetrics(); void setGatheringMetrics( boolean gatheringMetrics ); boolean isShowingSubComponents(); void setShowingSubComponents( boolean showingSubComponents ); boolean isSetLogfile(); void setSetLogfile( boolean setLogfile ); boolean isSetAppendLogfile(); void setSetAppendLogfile( boolean setAppendLogfile ); String getLogFileName(); void setLogFileName( String fileName ); boolean isCreateParentFolder(); void setCreateParentFolder( boolean createParentFolder ); Long getPassedBatchId(); void setPassedBatchId( Long passedBatchId ); String getRunConfiguration(); void setRunConfiguration( String runConfiguration ); boolean isLogRemoteExecutionLocally(); void setLogRemoteExecutionLocally( boolean logRemoteExecutionLocally ); static final String XML_TAG; }### Answer:
@Test public void testDefaultPassedBatchId() { TransExecutionConfiguration tec = new TransExecutionConfiguration(); assertEquals( "default passedBatchId value must be null", null, tec.getPassedBatchId() ); } |
### Question:
StringObjectId implements ObjectId, Comparable<StringObjectId> { public StringObjectId( String id ) { this.id = id; } StringObjectId( String id ); StringObjectId( ObjectId objectId ); @Override boolean equals( Object obj ); @Override int hashCode(); @Override int compareTo( StringObjectId o ); @Override String toString(); @Override String getId(); }### Answer:
@Test public void testStringObjectId() { String expectedId = UUID.randomUUID().toString(); StringObjectId obj = new StringObjectId( expectedId ); assertEquals( expectedId, obj.getId() ); assertEquals( expectedId, obj.toString() ); assertEquals( expectedId.hashCode(), obj.hashCode() ); assertFalse( obj.equals( null ) ); assertTrue( obj.equals( obj ) ); assertEquals( 0, obj.compareTo( obj ) ); StringObjectId clone = new StringObjectId( obj ); assertNotSame( obj, clone ); assertEquals( obj.getId(), clone.getId() ); } |
### Question:
DateCache { public DateCache() { cache = new HashMap<String, Date>(); } DateCache(); void populate( String datePattern, int fromYear, int toYear ); void addDate( String dateString, Date date ); Date lookupDate( String dateString ); int getSize(); static void main( String[] args ); }### Answer:
@SuppressWarnings( "deprecation" ) @Test public void testDateCache() { DateCache cache = new DateCache(); cache.populate( "yyyy-MM-dd", 2016, 2016 ); assertEquals( 366, cache.getSize() ); assertEquals( Calendar.FEBRUARY, cache.lookupDate( "2016-02-29" ).getMonth() ); assertEquals( 29, cache.lookupDate( "2016-02-29" ).getDate() ); assertEquals( ( 2016 - 1900 ), cache.lookupDate( "2016-02-29" ).getYear() ); } |
### Question:
LookupReferencesException extends KettleException { public String objectTypePairsToString() { StringBuilder result = new StringBuilder(); for ( Map.Entry entry : objectTypePairs.entrySet() ) { if ( entry.getKey() != null ) { result.append( Const.CR ); result.append( "\"" ); result.append( entry.getKey() ); result.append( "\"" ); result.append( " [" ); result.append( entry.getValue() ); result.append( "] " ); } } return result.toString(); } LookupReferencesException( Map<String, RepositoryObjectType> objectTypePairs ); LookupReferencesException( String message, Map<String, RepositoryObjectType> objectTypePairs ); LookupReferencesException( Throwable cause, Map<String, RepositoryObjectType> objectTypePairs ); LookupReferencesException( String message, Throwable cause,
Map<String, RepositoryObjectType> objectTypePairs ); String objectTypePairsToString(); static final long serialVersionUID; }### Answer:
@Test public void testObjectTypePairsToString() throws Exception { Exception cause = new NullPointerException(); Map<String, RepositoryObjectType> notFoundedReferences = new LinkedHashMap<String, RepositoryObjectType>(); String pathToTransStub = "/path/Trans.ktr"; String pathToJobStub = "/path/Job.ktr"; notFoundedReferences.put( pathToTransStub, RepositoryObjectType.TRANSFORMATION ); notFoundedReferences.put( pathToJobStub, RepositoryObjectType.JOB ); String expectedOutput = System.lineSeparator() + "\"/path/Trans.ktr\" [transformation] " + System.lineSeparator() + "\"/path/Job.ktr\" [job] "; try { throw new LookupReferencesException( cause, notFoundedReferences ); } catch ( LookupReferencesException testedException ) { String actual = testedException.objectTypePairsToString(); assertEquals( expectedOutput, actual ); assertNotNull( testedException.getCause() ); } } |
### Question:
FileInputList { public String[] getUrlStrings() { String[] fileStrings = new String[ files.size() ]; for ( int i = 0; i < fileStrings.length; i++ ) { fileStrings[ i ] = files.get( i ).getPublicURIString(); } return fileStrings; } static String getRequiredFilesDescription( List<FileObject> nonExistantFiles ); static String[] createFilePathList( VariableSpace space, String[] fileName, String[] fileMask,
String[] excludeFileMask, String[] fileRequired ); static String[] createFilePathList( VariableSpace space, String[] fileName, String[] fileMask,
String[] excludeFileMask, String[] fileRequired,
boolean[] includeSubdirs ); static String[] createFilePathList( VariableSpace space, String[] fileName, String[] fileMask,
String[] excludeFileMask, String[] fileRequired, boolean[] includeSubdirs,
FileTypeFilter[] filters ); static FileInputList createFileList( VariableSpace space, String[] fileName, String[] fileMask,
String[] excludeFileMask, String[] fileRequired ); static FileInputList createFileList( VariableSpace space, String[] fileName, String[] fileMask,
String[] excludeFileMask, String[] fileRequired,
boolean[] includeSubdirs ); static FileInputList createFileList( VariableSpace space, String[] fileName, String[] fileMask,
String[] excludeFileMask, String[] fileRequired, boolean[] includeSubdirs,
FileTypeFilter[] fileTypeFilters ); static FileInputList createFolderList( VariableSpace space, String[] folderName, String[] folderRequired ); List<FileObject> getFiles(); String[] getFileStrings(); String[] getUrlStrings(); List<FileObject> getNonAccessibleFiles(); List<FileObject> getNonExistantFiles(); void addFile( FileObject file ); void addNonAccessibleFile( FileObject file ); void addNonExistantFile( FileObject file ); void sortFiles(); FileObject getFile( int i ); int nrOfFiles(); int nrOfMissingFiles(); static FileInputList createFileList( VariableSpace space, String[] fileName, String[] fileMask,
String[] fileRequired, boolean[] includeSubdirs ); static String[] createFilePathList( VariableSpace space, String[] fileName, String[] fileMask,
String[] fileRequired ); }### Answer:
@Test public void testGetUrlStrings() throws Exception { String sFileA = "hdfs: String sFileB = "file: FileObject fileA = mock( FileObject.class ); FileObject fileB = mock( FileObject.class ); when( fileA.getPublicURIString() ).thenReturn( sFileA ); when( fileB.getPublicURIString() ).thenReturn( sFileB ); FileInputList fileInputList = new FileInputList(); fileInputList.addFile( fileA ); fileInputList.addFile( fileB ); String[] result = fileInputList.getUrlStrings(); assertEquals( 2, result.length ); assertEquals( sFileA, result[ 0 ] ); assertEquals( sFileB, result[ 1 ] ); } |
### Question:
DataHandler extends AbstractXulEventHandler { public void clearOptionsData() { getControls(); if ( optionsParameterTree != null ) { optionsParameterTree.getRootChildren().removeAll(); } } DataHandler(); void loadConnectionData(); void loadAccessData(); void editOptions( int index ); void clearOptionsData(); void getOptionHelp(); void setDeckChildIndex(); void onPoolingCheck(); void onClusterCheck(); Object getData(); void setData( Object data ); void pushCache(); void popCache(); void onCancel(); void onOK(); void testDatabaseConnection(); void restoreDefaults(); void poolingRowChange( int idx ); void disablePortIfInstancePopulated(); void handleUseSecurityCheckbox(); static final SortedMap<String, DatabaseInterface> connectionMap; static final Map<String, String> connectionNametoID; }### Answer:
@Test public void testClearOptionsData() throws Exception { } |
### Question:
XMLCheck { public static boolean isXMLWellFormed( InputStream is ) throws KettleException { boolean retval = false; try { SAXParserFactory factory = XMLParserFactoryProducer.createSecureSAXParserFactory(); XMLTreeHandler handler = new XMLTreeHandler(); SAXParser saxParser = factory.newSAXParser(); saxParser.parse( is, handler ); retval = true; } catch ( Exception e ) { throw new KettleException( e ); } return retval; } static final boolean isXMLFileWellFormed( FileObject file ); static boolean isXMLWellFormed( InputStream is ); }### Answer:
@Test( expected = KettleException.class ) public void exceptionIsThrownWhenParsingXmlWithBigAmountOfExternalEntities() throws KettleException { final String maliciousXml = "<?xml version=\"1.0\"?>\n" + "<!DOCTYPE lolz [\n" + " <!ENTITY lol \"lol\">\n" + " <!ELEMENT lolz (#PCDATA)>\n" + " <!ENTITY lol1 \"&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;\">\n" + " <!ENTITY lol2 \"&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;\">\n" + " <!ENTITY lol3 \"&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;\">\n" + " <!ENTITY lol4 \"&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;\">\n" + " <!ENTITY lol5 \"&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;\">\n" + " <!ENTITY lol6 \"&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;\">\n" + " <!ENTITY lol7 \"&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;\">\n" + " <!ENTITY lol8 \"&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;\">\n" + " <!ENTITY lol9 \"&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;\">\n" + "]>\n" + "<lolz>&lol9;</lolz>"; XMLCheck.isXMLWellFormed( new ByteArrayInputStream( maliciousXml.getBytes() ) ); } |
### Question:
KettleVFS { public static boolean startsWithScheme( String vfsFileName ) { FileSystemManager fsManager = getInstance().getFileSystemManager(); boolean found = false; String[] schemes = fsManager.getSchemes(); for ( int i = 0; i < schemes.length; i++ ) { if ( vfsFileName.startsWith( schemes[i] + ":" ) ) { found = true; break; } } return found; } private KettleVFS(); FileSystemManager getFileSystemManager(); static KettleVFS getInstance(); static FileObject getFileObject( String vfsFilename ); static FileObject getFileObject( String vfsFilename, VariableSpace space ); static FileObject getFileObject( String vfsFilename, FileSystemOptions fsOptions ); static FileObject getFileObject( String vfsFilename, VariableSpace space, FileSystemOptions fsOptions ); static String getTextFileContent( String vfsFilename, String charSetName ); static String getTextFileContent( String vfsFilename, VariableSpace space, String charSetName ); static boolean fileExists( String vfsFilename ); static boolean fileExists( String vfsFilename, VariableSpace space ); static InputStream getInputStream( FileObject fileObject ); static InputStream getInputStream( String vfsFilename ); static InputStream getInputStream( String vfsFilename, VariableSpace space ); static OutputStream getOutputStream( FileObject fileObject, boolean append ); static OutputStream getOutputStream( String vfsFilename, boolean append ); static OutputStream getOutputStream( String vfsFilename, VariableSpace space, boolean append ); static OutputStream getOutputStream( String vfsFilename, VariableSpace space,
FileSystemOptions fsOptions, boolean append ); static String getFilename( FileObject fileObject ); static String getFriendlyURI( String filename ); static String getFriendlyURI( FileObject fileObject ); static FileObject createTempFile( String prefix, String suffix, String directory ); static FileObject createTempFile( String prefix, String suffix, String directory, VariableSpace space ); static Comparator<FileObject> getComparator(); @Deprecated static FileInputStream getFileInputStream( FileObject fileObject ); static boolean startsWithScheme( String vfsFileName ); static void closeEmbeddedFileSystem( String embeddedMetastoreKey ); }### Answer:
@Test public void testStartsWithScheme() { String fileName = "zip:file: assertTrue( KettleVFS.startsWithScheme( fileName ) ); fileName = "SavedLinkedres.zip!Calculate median and percentiles using the group by steps.ktr"; assertFalse( KettleVFS.startsWithScheme( fileName ) ); } |
### Question:
SingleRowRowSet extends BaseRowSet implements Comparable<RowSet>, RowSet { @Override public boolean putRow( RowMetaInterface rowMeta, Object[] rowData ) { this.rowMeta = rowMeta; this.row = rowData; return true; } @Override Object[] getRow(); @Override Object[] getRowImmediate(); @Override Object[] getRowWait( long timeout, TimeUnit tu ); @Override boolean putRow( RowMetaInterface rowMeta, Object[] rowData ); @Override boolean putRowWait( RowMetaInterface rowMeta, Object[] rowData, long time, TimeUnit tu ); @Override int size(); @Override void clear(); }### Answer:
@Test public void testPutRow() throws Exception { rowSet.putRow( new RowMeta(), row ); assertSame( row, rowSet.getRow() ); } |
### Question:
SingleRowRowSet extends BaseRowSet implements Comparable<RowSet>, RowSet { @Override public boolean putRowWait( RowMetaInterface rowMeta, Object[] rowData, long time, TimeUnit tu ) { return putRow( rowMeta, rowData ); } @Override Object[] getRow(); @Override Object[] getRowImmediate(); @Override Object[] getRowWait( long timeout, TimeUnit tu ); @Override boolean putRow( RowMetaInterface rowMeta, Object[] rowData ); @Override boolean putRowWait( RowMetaInterface rowMeta, Object[] rowData, long time, TimeUnit tu ); @Override int size(); @Override void clear(); }### Answer:
@Test public void testPutRowWait() throws Exception { rowSet.putRowWait( new RowMeta(), row, 1, TimeUnit.SECONDS ); assertSame( row, rowSet.getRowWait( 1, TimeUnit.SECONDS ) ); } |
### Question:
SingleRowRowSet extends BaseRowSet implements Comparable<RowSet>, RowSet { @Override public Object[] getRowImmediate() { return getRow(); } @Override Object[] getRow(); @Override Object[] getRowImmediate(); @Override Object[] getRowWait( long timeout, TimeUnit tu ); @Override boolean putRow( RowMetaInterface rowMeta, Object[] rowData ); @Override boolean putRowWait( RowMetaInterface rowMeta, Object[] rowData, long time, TimeUnit tu ); @Override int size(); @Override void clear(); }### Answer:
@Test public void testGetRowImmediate() throws Exception { rowSet.putRow( new RowMeta(), row ); assertSame( row, rowSet.getRowImmediate() ); } |
### Question:
SingleRowRowSet extends BaseRowSet implements Comparable<RowSet>, RowSet { @Override public int size() { return row == null ? 0 : 1; } @Override Object[] getRow(); @Override Object[] getRowImmediate(); @Override Object[] getRowWait( long timeout, TimeUnit tu ); @Override boolean putRow( RowMetaInterface rowMeta, Object[] rowData ); @Override boolean putRowWait( RowMetaInterface rowMeta, Object[] rowData, long time, TimeUnit tu ); @Override int size(); @Override void clear(); }### Answer:
@Test public void testSize() throws Exception { assertEquals( 0, rowSet.size() ); rowSet.putRow( new RowMeta(), row ); assertEquals( 1, rowSet.size() ); rowSet.clear(); assertEquals( 0, rowSet.size() ); } |
### Question:
DateDetector { public static String getRegexpByDateFormat( String dateFormat ) { return getRegexpByDateFormat( dateFormat, null ); } private DateDetector(); static String getRegexpByDateFormat( String dateFormat ); static String getRegexpByDateFormat( String dateFormat, String locale ); static String getDateFormatByRegex( String regex ); static String getDateFormatByRegex( String regex, String locale ); static Date getDateFromString( String dateString ); static Date getDateFromString( String dateString, String locale ); static Date getDateFromStringByFormat( String dateString, String dateFormat ); static String detectDateFormat( String dateString ); static String detectDateFormat( String dateString, String locale ); static String detectDateFormatBiased( String dateString, String locale, String desiredKey ); static BidiMap getDateFormatToRegExps( String locale ); static boolean isValidDate( String dateString, String dateFormat ); static boolean isValidDate( String dateString ); static boolean isValidDateFormatToStringDate( String dateFormat, String dateString ); static boolean isValidDateFormatToStringDate( String dateFormat, String dateString, String locale ); }### Answer:
@Test public void testGetRegexpByDateFormat() { assertNull( DateDetector.getRegexpByDateFormat( null ) ); assertEquals( SAMPLE_REGEXP, DateDetector.getRegexpByDateFormat( SAMPLE_DATE_FORMAT ) ); }
@Test public void testGetRegexpByDateFormatLocale() { assertNull( DateDetector.getRegexpByDateFormat( null, null ) ); assertNull( DateDetector.getRegexpByDateFormat( null, LOCALE_en_US ) ); assertNull( DateDetector.getRegexpByDateFormat( SAMPLE_DATE_FORMAT_US ) ); assertEquals( SAMPLE_REGEXP_US, DateDetector.getRegexpByDateFormat( SAMPLE_DATE_FORMAT_US, LOCALE_en_US ) ); } |
### Question:
DateDetector { public static String getDateFormatByRegex( String regex ) { return getDateFormatByRegex( regex, null ); } private DateDetector(); static String getRegexpByDateFormat( String dateFormat ); static String getRegexpByDateFormat( String dateFormat, String locale ); static String getDateFormatByRegex( String regex ); static String getDateFormatByRegex( String regex, String locale ); static Date getDateFromString( String dateString ); static Date getDateFromString( String dateString, String locale ); static Date getDateFromStringByFormat( String dateString, String dateFormat ); static String detectDateFormat( String dateString ); static String detectDateFormat( String dateString, String locale ); static String detectDateFormatBiased( String dateString, String locale, String desiredKey ); static BidiMap getDateFormatToRegExps( String locale ); static boolean isValidDate( String dateString, String dateFormat ); static boolean isValidDate( String dateString ); static boolean isValidDateFormatToStringDate( String dateFormat, String dateString ); static boolean isValidDateFormatToStringDate( String dateFormat, String dateString, String locale ); }### Answer:
@Test public void testGetDateFormatByRegex() { assertNull( DateDetector.getDateFormatByRegex( null ) ); assertEquals( SAMPLE_DATE_FORMAT, DateDetector.getDateFormatByRegex( SAMPLE_REGEXP ) ); }
@Test public void testGetDateFormatByRegexLocale() { assertNull( DateDetector.getDateFormatByRegex( null, null ) ); assertNull( DateDetector.getDateFormatByRegex( null, LOCALE_en_US ) ); assertEquals( SAMPLE_DATE_FORMAT, DateDetector.getDateFormatByRegex( SAMPLE_REGEXP_US ) ); assertEquals( SAMPLE_DATE_FORMAT_US, DateDetector.getDateFormatByRegex( SAMPLE_REGEXP_US, LOCALE_en_US ) ); } |
### Question:
DateDetector { public static Date getDateFromString( String dateString ) throws ParseException { String dateFormat = detectDateFormat( dateString ); if ( dateFormat == null ) { throw new ParseException( "Unknown date format.", 0 ); } return getDateFromStringByFormat( dateString, dateFormat ); } private DateDetector(); static String getRegexpByDateFormat( String dateFormat ); static String getRegexpByDateFormat( String dateFormat, String locale ); static String getDateFormatByRegex( String regex ); static String getDateFormatByRegex( String regex, String locale ); static Date getDateFromString( String dateString ); static Date getDateFromString( String dateString, String locale ); static Date getDateFromStringByFormat( String dateString, String dateFormat ); static String detectDateFormat( String dateString ); static String detectDateFormat( String dateString, String locale ); static String detectDateFormatBiased( String dateString, String locale, String desiredKey ); static BidiMap getDateFormatToRegExps( String locale ); static boolean isValidDate( String dateString, String dateFormat ); static boolean isValidDate( String dateString ); static boolean isValidDateFormatToStringDate( String dateFormat, String dateString ); static boolean isValidDateFormatToStringDate( String dateFormat, String dateString, String locale ); }### Answer:
@Test public void testGetDateFromString() throws ParseException { assertEquals( SAMPLE_DATE_US, DateDetector.getDateFromString( SAMPLE_DATE_STRING_US ) ); try { DateDetector.getDateFromString( null ); } catch ( ParseException e ) { } }
@Test public void testGetDateFromStringLocale() throws ParseException { assertEquals( SAMPLE_DATE_US, DateDetector.getDateFromString( SAMPLE_DATE_STRING_US, LOCALE_en_US ) ); try { DateDetector.getDateFromString( null ); } catch ( ParseException e ) { } try { DateDetector.getDateFromString( null, null ); } catch ( ParseException e ) { } } |
### Question:
DateDetector { public static Date getDateFromStringByFormat( String dateString, String dateFormat ) throws ParseException { if ( dateFormat == null ) { throw new ParseException( "Unknown date format. Format is null. ", 0 ); } if ( dateString == null ) { throw new ParseException( "Unknown date string. Date string is null. ", 0 ); } SimpleDateFormat simpleDateFormat = new SimpleDateFormat( dateFormat ); simpleDateFormat.setLenient( false ); return simpleDateFormat.parse( dateString ); } private DateDetector(); static String getRegexpByDateFormat( String dateFormat ); static String getRegexpByDateFormat( String dateFormat, String locale ); static String getDateFormatByRegex( String regex ); static String getDateFormatByRegex( String regex, String locale ); static Date getDateFromString( String dateString ); static Date getDateFromString( String dateString, String locale ); static Date getDateFromStringByFormat( String dateString, String dateFormat ); static String detectDateFormat( String dateString ); static String detectDateFormat( String dateString, String locale ); static String detectDateFormatBiased( String dateString, String locale, String desiredKey ); static BidiMap getDateFormatToRegExps( String locale ); static boolean isValidDate( String dateString, String dateFormat ); static boolean isValidDate( String dateString ); static boolean isValidDateFormatToStringDate( String dateFormat, String dateString ); static boolean isValidDateFormatToStringDate( String dateFormat, String dateString, String locale ); }### Answer:
@Test public void testGetDateFromStringByFormat() throws ParseException { assertEquals( SAMPLE_DATE, DateDetector.getDateFromStringByFormat( SAMPLE_DATE_STRING, SAMPLE_DATE_FORMAT ) ); try { DateDetector.getDateFromStringByFormat( SAMPLE_DATE_STRING, null ); } catch ( ParseException e ) { } try { DateDetector.getDateFromStringByFormat( null, SAMPLE_DATE_FORMAT ); } catch ( ParseException e ) { } } |
### Question:
DateDetector { public static String detectDateFormat( String dateString ) { return detectDateFormat( dateString, null ); } private DateDetector(); static String getRegexpByDateFormat( String dateFormat ); static String getRegexpByDateFormat( String dateFormat, String locale ); static String getDateFormatByRegex( String regex ); static String getDateFormatByRegex( String regex, String locale ); static Date getDateFromString( String dateString ); static Date getDateFromString( String dateString, String locale ); static Date getDateFromStringByFormat( String dateString, String dateFormat ); static String detectDateFormat( String dateString ); static String detectDateFormat( String dateString, String locale ); static String detectDateFormatBiased( String dateString, String locale, String desiredKey ); static BidiMap getDateFormatToRegExps( String locale ); static boolean isValidDate( String dateString, String dateFormat ); static boolean isValidDate( String dateString ); static boolean isValidDateFormatToStringDate( String dateFormat, String dateString ); static boolean isValidDateFormatToStringDate( String dateFormat, String dateString, String locale ); }### Answer:
@Test public void testDetectDateFormat() { assertEquals( SAMPLE_DATE_FORMAT, DateDetector.detectDateFormat( SAMPLE_DATE_STRING, LOCALE_es ) ); assertNull( DateDetector.detectDateFormat( null ) ); } |
### Question:
DateDetector { public static boolean isValidDate( String dateString, String dateFormat ) { try { getDateFromStringByFormat( dateString, dateFormat ); return true; } catch ( ParseException e ) { return false; } } private DateDetector(); static String getRegexpByDateFormat( String dateFormat ); static String getRegexpByDateFormat( String dateFormat, String locale ); static String getDateFormatByRegex( String regex ); static String getDateFormatByRegex( String regex, String locale ); static Date getDateFromString( String dateString ); static Date getDateFromString( String dateString, String locale ); static Date getDateFromStringByFormat( String dateString, String dateFormat ); static String detectDateFormat( String dateString ); static String detectDateFormat( String dateString, String locale ); static String detectDateFormatBiased( String dateString, String locale, String desiredKey ); static BidiMap getDateFormatToRegExps( String locale ); static boolean isValidDate( String dateString, String dateFormat ); static boolean isValidDate( String dateString ); static boolean isValidDateFormatToStringDate( String dateFormat, String dateString ); static boolean isValidDateFormatToStringDate( String dateFormat, String dateString, String locale ); }### Answer:
@Test public void testIsValidDate() { assertTrue( DateDetector.isValidDate( SAMPLE_DATE_STRING_US ) ); assertFalse( DateDetector.isValidDate( null ) ); assertTrue( DateDetector.isValidDate( SAMPLE_DATE_STRING, SAMPLE_DATE_FORMAT ) ); assertFalse( DateDetector.isValidDate( SAMPLE_DATE_STRING, null ) ); } |
### Question:
DateDetector { public static boolean isValidDateFormatToStringDate( String dateFormat, String dateString ) { String detectedDateFormat = detectDateFormat( dateString ); if ( ( dateFormat != null ) && ( dateFormat.equals( detectedDateFormat ) ) ) { return true; } return false; } private DateDetector(); static String getRegexpByDateFormat( String dateFormat ); static String getRegexpByDateFormat( String dateFormat, String locale ); static String getDateFormatByRegex( String regex ); static String getDateFormatByRegex( String regex, String locale ); static Date getDateFromString( String dateString ); static Date getDateFromString( String dateString, String locale ); static Date getDateFromStringByFormat( String dateString, String dateFormat ); static String detectDateFormat( String dateString ); static String detectDateFormat( String dateString, String locale ); static String detectDateFormatBiased( String dateString, String locale, String desiredKey ); static BidiMap getDateFormatToRegExps( String locale ); static boolean isValidDate( String dateString, String dateFormat ); static boolean isValidDate( String dateString ); static boolean isValidDateFormatToStringDate( String dateFormat, String dateString ); static boolean isValidDateFormatToStringDate( String dateFormat, String dateString, String locale ); }### Answer:
@Test public void testIsValidDateFormatToStringDate() { assertTrue( DateDetector.isValidDateFormatToStringDate( SAMPLE_DATE_FORMAT_US, SAMPLE_DATE_STRING_US ) ); assertFalse( DateDetector.isValidDateFormatToStringDate( null, SAMPLE_DATE_STRING_US ) ); assertFalse( DateDetector.isValidDateFormatToStringDate( SAMPLE_DATE_FORMAT_US, null ) ); }
@Test public void testIsValidDateFormatToStringDateLocale() { assertTrue( DateDetector.isValidDateFormatToStringDate( SAMPLE_DATE_FORMAT_US, SAMPLE_DATE_STRING_US, LOCALE_en_US ) ); assertFalse( DateDetector.isValidDateFormatToStringDate( null, SAMPLE_DATE_STRING, LOCALE_en_US ) ); assertFalse( DateDetector.isValidDateFormatToStringDate( SAMPLE_DATE_FORMAT_US, null, LOCALE_en_US ) ); assertTrue( DateDetector.isValidDateFormatToStringDate( SAMPLE_DATE_FORMAT_US, SAMPLE_DATE_STRING_US, null ) ); } |
### Question:
StringEvaluator { public int getCount() { return count; } StringEvaluator(); StringEvaluator( boolean tryTrimming ); StringEvaluator( boolean tryTrimming, List<String> numberFormats, List<String> dateFormats ); StringEvaluator( boolean tryTrimming, String[] numberFormats, String[] dateFormats ); void evaluateString( String value ); StringEvaluationResult getAdvicedResult(); String[] getDateFormats(); String[] getNumberFormats(); Set<String> getValues(); List<StringEvaluationResult> getStringEvaluationResults(); int getCount(); int getMaxLength(); }### Answer:
@Test public void testGetCount() { List<String> strings = Arrays.asList( "02/29/2000", "03/29/2000" ); for ( String string : strings ) { evaluator.evaluateString( string ); } assertEquals( strings.size(), evaluator.getCount() ); } |
### Question:
EnvUtil { public static void environmentInit() throws KettleException { if ( Thread.currentThread().getContextClassLoader() == null ) { Thread.currentThread().setContextClassLoader( ClassLoader.getSystemClassLoader() ); } Map<Object, Object> kettleProperties = EnvUtil.readProperties( Const.KETTLE_PROPERTIES ); insertDefaultValues( kettleProperties ); applyKettleProperties( kettleProperties ); System.getProperties().put( Const.INTERNAL_VARIABLE_CLUSTER_SIZE, "1" ); System.getProperties().put( Const.INTERNAL_VARIABLE_SLAVE_SERVER_NUMBER, "0" ); System.getProperties().put( Const.INTERNAL_VARIABLE_SLAVE_SERVER_NAME, "slave-trans-name" ); System.getProperties().put( Const.INTERNAL_VARIABLE_STEP_COPYNR, "0" ); System.getProperties().put( Const.INTERNAL_VARIABLE_STEP_NAME, "step-name" ); System.getProperties().put( Const.INTERNAL_VARIABLE_STEP_PARTITION_ID, "partition-id" ); System.getProperties().put( Const.INTERNAL_VARIABLE_STEP_PARTITION_NR, "0" ); System.getProperties().put( Const.INTERNAL_VARIABLE_STEP_UNIQUE_COUNT, "1" ); System.getProperties().put( Const.INTERNAL_VARIABLE_STEP_UNIQUE_NUMBER, "0" ); } static Properties readProperties( final String fileName ); static void environmentInit(); static void applyKettleProperties( Map<?, ?> kettleProperties ); static void applyKettleProperties( Map<?, ?> kettleProperties, boolean override ); static void addInternalVariables( Properties prop ); static final String[] getEnvironmentVariablesForRuntimeExec(); static final String getSystemPropertyStripQuotes( String key, String def ); static final String getSystemProperty( String key, String def ); static final String getSystemProperty( String key ); static Locale createLocale( String localeCode ); static TimeZone createTimeZone( String timeZoneId ); static String[] getTimeZones(); static String[] getLocaleList(); }### Answer:
@Test public void vfsUserDirIsRoot_IsPublishedOnInitialisation() throws Exception { EnvUtil.environmentInit(); assertNotNull( Variables.getADefaultVariableSpace().getVariable( Const.VFS_USER_DIR_IS_ROOT ) ); assertNotNull( System.getProperty( Const.VFS_USER_DIR_IS_ROOT ) ); } |
### Question:
EnvUtil { public static Locale createLocale( String localeCode ) { Locale resultLocale = null; if ( !Utils.isEmpty( localeCode ) ) { StringTokenizer parser = new StringTokenizer( localeCode, "_" ); if ( parser.countTokens() == 2 ) { resultLocale = new Locale( parser.nextToken(), parser.nextToken() ); } else { resultLocale = new Locale( localeCode ); } } return resultLocale; } static Properties readProperties( final String fileName ); static void environmentInit(); static void applyKettleProperties( Map<?, ?> kettleProperties ); static void applyKettleProperties( Map<?, ?> kettleProperties, boolean override ); static void addInternalVariables( Properties prop ); static final String[] getEnvironmentVariablesForRuntimeExec(); static final String getSystemPropertyStripQuotes( String key, String def ); static final String getSystemProperty( String key, String def ); static final String getSystemProperty( String key ); static Locale createLocale( String localeCode ); static TimeZone createTimeZone( String timeZoneId ); static String[] getTimeZones(); static String[] getLocaleList(); }### Answer:
@Test public void createLocale_Null() throws Exception { assertNull( EnvUtil.createLocale( null ) ); }
@Test public void createLocale_Empty() throws Exception { assertNull( EnvUtil.createLocale( "" ) ); }
@Test public void createLocale_SingleCode() throws Exception { assertEquals( Locale.ENGLISH, EnvUtil.createLocale( "en" ) ); }
@Test public void createLocale_DoubleCode() throws Exception { assertEquals( Locale.US, EnvUtil.createLocale( "en_US" ) ); } |
### Question:
TemporaryCacheManager { public void cacheSmallBlock(SmallBlock smallBlock) { smallBlockCacheMap.put(smallBlock.getHeader().getHash(), smallBlock); } private TemporaryCacheManager(); static TemporaryCacheManager getInstance(); void cacheSmallBlock(SmallBlock smallBlock); void cacheSmallBlockWithRequest(NulsDigestData requestHash, SmallBlock smallBlock); SmallBlock getSmallBlockByRequest(NulsDigestData requestHash); SmallBlock getSmallBlockByHash(NulsDigestData blockHash); boolean cacheTx(Transaction tx); Transaction getTx(NulsDigestData hash); void removeSmallBlock(NulsDigestData hash); void clear(); void destroy(); boolean containsTx(NulsDigestData txHash); int getSmallBlockCount(); int getTxCount(); }### Answer:
@Test public void cacheSmallBlock() { SmallBlock smallBlock = new SmallBlock(); BlockHeader header = new BlockHeader(); NulsDigestData hash = NulsDigestData.calcDigestData("abcdefg".getBytes()); header.setHash(hash); manager.cacheSmallBlock(smallBlock); assertTrue(true); this.getSmallBlock(hash, smallBlock); this.removeSmallBlock(hash); manager.cacheSmallBlock(smallBlock); this.clear(); } |
### Question:
RoundManager { public MeetingRound getRoundByIndex(long roundIndex) { MeetingRound round = null; for (int i = roundList.size() - 1; i >= 0; i--) { round = roundList.get(i); if (round.getIndex() == roundIndex) { break; } } return round; } RoundManager(Chain chain); MeetingRound getRoundByIndex(long roundIndex); void addRound(MeetingRound meetingRound); void checkIsNeedReset(); boolean clearRound(int count); MeetingRound getCurrentRound(); MeetingRound initRound(); MeetingRound resetRound(boolean isRealTime); MeetingRound getNextRound(BlockExtendsData roundData, boolean isRealTime); Chain getChain(); List<MeetingRound> getRoundList(); AccountService getAccountService(); }### Answer:
@Test public void testGetRoundByIndex() { assertNotNull(roundManager); assertNotNull(roundManager.getChain()); long index = 1002L; assertEquals(0, roundManager.getRoundList().size()); MeetingRound round = new MeetingRound(); round.setIndex(index); roundManager.addRound(round); assertEquals(1, roundManager.getRoundList().size()); MeetingRound round2 = roundManager.getRoundByIndex(index); assertNotNull(round2); assertEquals(round, round2); } |
### Question:
RoundManager { public boolean clearRound(int count) { Lockers.ROUND_LOCK.lock(); boolean doit = false; try { while (roundList.size() > count) { doit = true; roundList.remove(0); } if (doit) { MeetingRound round = roundList.get(0); round.setPreRound(null); } return true; } finally { Lockers.ROUND_LOCK.unlock(); } } RoundManager(Chain chain); MeetingRound getRoundByIndex(long roundIndex); void addRound(MeetingRound meetingRound); void checkIsNeedReset(); boolean clearRound(int count); MeetingRound getCurrentRound(); MeetingRound initRound(); MeetingRound resetRound(boolean isRealTime); MeetingRound getNextRound(BlockExtendsData roundData, boolean isRealTime); Chain getChain(); List<MeetingRound> getRoundList(); AccountService getAccountService(); }### Answer:
@Test public void testClearRound() { MeetingRound round = new MeetingRound(); round.setIndex(1l); roundManager.addRound(round); round = new MeetingRound(); round.setIndex(2l); roundManager.addRound(round); round = new MeetingRound(); round.setIndex(3l); roundManager.addRound(round); round = new MeetingRound(); round.setIndex(4l); roundManager.addRound(round); round = new MeetingRound(); round.setIndex(5l); roundManager.addRound(round); round = new MeetingRound(); round.setIndex(6l); roundManager.addRound(round); round = new MeetingRound(); round.setIndex(7l); roundManager.addRound(round); assertEquals(7, roundManager.getRoundList().size()); assertEquals(7L, roundManager.getCurrentRound().getIndex()); boolean success = roundManager.clearRound(3); assert(success); assertEquals(3, roundManager.getRoundList().size()); assertEquals(7L, roundManager.getCurrentRound().getIndex()); } |
### Question:
RoundManager { public MeetingRound initRound() { MeetingRound currentRound = resetRound(false); if (currentRound.getPreRound() == null) { BlockExtendsData extendsData = null; List<BlockHeader> blockHeaderList = chain.getAllBlockHeaderList(); for (int i = blockHeaderList.size() - 1; i >= 0; i--) { BlockHeader blockHeader = blockHeaderList.get(i); extendsData = new BlockExtendsData(blockHeader.getExtend()); if (extendsData.getRoundIndex() < currentRound.getIndex()) { break; } } MeetingRound preRound = getNextRound(extendsData, false); currentRound.setPreRound(preRound); } return currentRound; } RoundManager(Chain chain); MeetingRound getRoundByIndex(long roundIndex); void addRound(MeetingRound meetingRound); void checkIsNeedReset(); boolean clearRound(int count); MeetingRound getCurrentRound(); MeetingRound initRound(); MeetingRound resetRound(boolean isRealTime); MeetingRound getNextRound(BlockExtendsData roundData, boolean isRealTime); Chain getChain(); List<MeetingRound> getRoundList(); AccountService getAccountService(); }### Answer:
@Test public void testInitRound() { assertNotNull(roundManager); assertNotNull(roundManager.getChain()); Chain chain = roundManager.getChain(); assertNotNull(chain.getEndBlockHeader()); assert(chain.getAllBlockList().size() > 0); MeetingRound round = roundManager.initRound(); assertNotNull(round); assertEquals(round.getIndex(), 2L); Assert.assertEquals(round.getStartTime(), ProtocolConstant.BLOCK_TIME_INTERVAL_MILLIS + 1L); MeetingRound round2 = roundManager.getNextRound(null, false); assertNotNull(round2); assertEquals(round.getIndex(), round2.getIndex()); assertEquals(round.getStartTime(), round2.getStartTime()); round2 = roundManager.getNextRound(null, true); assertNotNull(round2); assert(round.getIndex() < round2.getIndex()); assert(round.getStartTime() < round2.getStartTime()); assertEquals("", 0d, round2.getTotalWeight(), 2200000d); } |
### Question:
ConsensusTool { public static SmallBlock getSmallBlock(Block block) { SmallBlock smallBlock = new SmallBlock(); smallBlock.setHeader(block.getHeader()); List<NulsDigestData> txHashList = new ArrayList<>(); for (Transaction tx : block.getTxs()) { txHashList.add(tx.getHash()); if (tx.isSystemTx()) { smallBlock.addBaseTx(tx); } } smallBlock.setTxHashList(txHashList); return smallBlock; } static SmallBlock getSmallBlock(Block block); static Block createBlock(BlockData blockData, Account account); static CoinBaseTransaction createCoinBaseTx(MeetingMember member, List<Transaction> txList, MeetingRound localRound, long unlockHeight); static YellowPunishTransaction createYellowPunishTx(Block preBlock, MeetingMember self, MeetingRound round); static CoinData getStopAgentCoinData(Agent agent, long lockTime); static CoinData getStopAgentCoinData(Agent agent, long lockTime, Long hight); static CoinData getStopAgentCoinData(byte[] address, long lockTime); static byte[] getStateRoot(BlockHeader blockHeader); }### Answer:
@Test public void testGetSmallBlock() { Block block = createBlock(); SmallBlock smallBlock = ConsensusTool.getSmallBlock(block); assertNotNull(smallBlock); assertEquals(smallBlock.getHeader(), block.getHeader()); assertEquals(smallBlock.getSubTxList().size() , 0); assertEquals(smallBlock.getTxHashList().get(0), block.getTxs().get(0).getHash()); } |
### Question:
RandomSeedUtils { public static byte[] createRandomSeed() { BigInteger value = new BigInteger(256, new Random()); byte[] result = value.toByteArray(); if (result.length > 32) { byte[] temp = new byte[32]; System.arraycopy(result, result.length - 32, temp, 0, 32); result = temp; } else if (result.length < 32) { byte[] temp = new byte[32]; System.arraycopy(result, 0, temp, 0, result.length); result = temp; } return result; } static byte[] createRandomSeed(); static byte[] getLastDigestEightBytes(byte[] bytes); static RandomSeedStatusPo CACHE_SEED; }### Answer:
@Test public void createRandomSeed() { for (int i = 0; i < 1000000; i++) { byte[] result = RandomSeedUtils.createRandomSeed(); assertEquals(result.length, 32); } } |
### Question:
RandomSeedUtils { public static byte[] getLastDigestEightBytes(byte[] bytes) { byte[] hash = Sha256Hash.hashTwice(bytes); byte[] result = new byte[8]; System.arraycopy(hash, bytes.length - 8, result, 0, 8); return result; } static byte[] createRandomSeed(); static byte[] getLastDigestEightBytes(byte[] bytes); static RandomSeedStatusPo CACHE_SEED; }### Answer:
@Test public void getLastDigestEightBytes() { byte[] seed = RandomSeedUtils.createRandomSeed(); byte[] hash = RandomSeedUtils.getLastDigestEightBytes(seed); byte[] hash2 = RandomSeedUtils.getLastDigestEightBytes(seed); assertTrue(ArraysTool.arrayEquals(hash, hash2)); assertEquals(hash.length, 8); } |
### Question:
BlockQueueProvider { public boolean put(BlockContainer blockContainer) { boolean receive = (blockContainer.getStatus() == BlockContainerStatus.RECEIVED); if (receive) { int status = BlockContainerStatus.RECEIVED; checkDownloadService(); if (!downloadService.isDownloadSuccess().isSuccess()) { status = BlockContainerStatus.DOWNLOADING; } blockContainer.setStatus(status); blockQueue.offer(blockContainer); } else { if (downloadBlockQueueHasDestory) { initDownloadQueue(); } downloadBlockQueue.offer(blockContainer); } return true; } private BlockQueueProvider(); static BlockQueueProvider getInstance(); boolean put(BlockContainer blockContainer); BlockContainer get(); long size(); void clear(); }### Answer:
@Test public void testPut() { assertNotNull(blockQueueProvider); assertEquals(0, blockQueueProvider.size()); Block block = new Block(); boolean result = blockQueueProvider.put(new BlockContainer(block, BlockContainerStatus.RECEIVED)); assertTrue(result); assertEquals(1, blockQueueProvider.size()); } |
### Question:
BlockQueueProvider { public BlockContainer get() { BlockContainer blockContainer = null; if (!downloadBlockQueueHasDestory) { blockContainer = downloadBlockQueue.poll(); } checkDownloadService(); boolean hasDownloadSuccess = downloadService.isDownloadSuccess().isSuccess(); if (blockContainer == null && hasDownloadSuccess && !downloadBlockQueueHasDestory) { downloadBlockQueueHasDestory = true; if (blockContainer == null) { blockContainer = blockQueue.poll(); } } else if (hasDownloadSuccess && blockContainer == null) { blockContainer = blockQueue.poll(); } return blockContainer; } private BlockQueueProvider(); static BlockQueueProvider getInstance(); boolean put(BlockContainer blockContainer); BlockContainer get(); long size(); void clear(); }### Answer:
@Test public void testGet() { assertNotNull(blockQueueProvider); assertEquals(0, blockQueueProvider.size()); if(downloadService.isDownloadSuccess().isSuccess()) { downloadService.setDownloadSuccess(false); } Block block = new Block(); boolean result = blockQueueProvider.put(new BlockContainer(block, BlockContainerStatus.RECEIVED)); assertTrue(result); assertEquals(1, blockQueueProvider.size()); BlockContainer blockContainer = blockQueueProvider.get(); assertNull(blockContainer); downloadService.setDownloadSuccess(true); blockContainer = blockQueueProvider.get(); assertNotNull(blockContainer); assertEquals(blockContainer.getBlock(), block); assertEquals(blockContainer.getStatus(), BlockContainerStatus.DOWNLOADING); assertEquals(0, blockQueueProvider.size()); block = new Block(); result = blockQueueProvider.put(new BlockContainer(block, BlockContainerStatus.RECEIVED)); assertTrue(result); blockContainer = blockQueueProvider.get(); assertNotNull(blockContainer); assertEquals(blockContainer.getBlock(), block); assertEquals(blockContainer.getStatus(), BlockContainerStatus.RECEIVED); } |
### Question:
BlockProcessTask implements Runnable { @Override public void run() { Lockers.CHAIN_LOCK.lock(); try { doTask(); } catch (Exception e) { Log.error(e); } catch (Error e) { Log.error(e); } catch (Throwable e) { Log.error(e); } finally { Lockers.CHAIN_LOCK.unlock(); } } BlockProcessTask(BlockProcess blockProcess); @Override void run(); }### Answer:
@Test public void testRun() { assertNotNull(blockProcessTask); if(downloadService.isDownloadSuccess().isSuccess()) { downloadService.setDownloadSuccess(false); } ConsensusStatusContext.setConsensusStatus(ConsensusStatus.WAIT_RUNNING); blockProcessTask.run(); assert(!ConsensusStatusContext.isRunning()); downloadService.setDownloadSuccess(true); blockProcessTask.run(); assert(ConsensusStatusContext.isRunning()); } |
### Question:
ChainContainer implements Cloneable { public MeetingRound getCurrentRound() { return roundManager.getCurrentRound(); } ChainContainer(Chain chain); boolean addBlock(Block block); Result verifyBlock(Block block); Result verifyBlock(Block block, boolean isDownload, boolean isNeedCheckCoinBaseTx); boolean verifyCoinBaseTx(Block block, MeetingRound currentRound, MeetingMember member); boolean verifyPunishTx(Block block, MeetingRound currentRound, MeetingMember member); Result verifyAndAddBlock(Block block, boolean isDownload, boolean isNeedCheckCoinBaseTx); boolean rollback(Block block); ChainContainer getBeforeTheForkChain(ChainContainer chainContainer); ChainContainer getAfterTheForkChain(ChainContainer chainContainer); MeetingRound getCurrentRound(); MeetingRound getOrResetCurrentRound(); MeetingRound getOrResetCurrentRound(boolean isRealTime); MeetingRound initRound(); void clearRound(int count); Block getBestBlock(); Chain getChain(); void setChain(Chain chain); @Override boolean equals(Object obj); RoundManager getRoundManager(); }### Answer:
@Test public void testInit() { assertNotNull(chain); assertNotNull(chainContainer); assertNotNull(chainContainer.getCurrentRound()); assertEquals(chainContainer.getCurrentRound().getMemberCount(), 1); } |
### Question:
TemporaryCacheManager { public boolean cacheTx(Transaction tx) { return txCacheMap.put(tx.getHash(), tx); } private TemporaryCacheManager(); static TemporaryCacheManager getInstance(); void cacheSmallBlock(SmallBlock smallBlock); void cacheSmallBlockWithRequest(NulsDigestData requestHash, SmallBlock smallBlock); SmallBlock getSmallBlockByRequest(NulsDigestData requestHash); SmallBlock getSmallBlockByHash(NulsDigestData blockHash); boolean cacheTx(Transaction tx); Transaction getTx(NulsDigestData hash); void removeSmallBlock(NulsDigestData hash); void clear(); void destroy(); boolean containsTx(NulsDigestData txHash); int getSmallBlockCount(); int getTxCount(); }### Answer:
@Test public void cacheTx() { Transaction tx = new CacheTestTx(); tx.setTime(1234567654L); try { tx.setHash(NulsDigestData.calcDigestData(tx.serializeForHash())); } catch (IOException e) { Log.error(e); } manager.cacheTx(tx); assertTrue(true); getTx(tx.getHash(), tx); } |
### Question:
ChainContainer implements Cloneable { public boolean rollback(Block block) { int length = chain.getAllBlockList().size(); if (block == null || length == 0) { return false; } Block bestBlock = chain.getBestBlock(); if (!block.getHeader().getHash().equals(bestBlock.getHeader().getHash())) { Log.warn("rollbackTransaction block is not best block"); return false; } if (length <= 2) { addBlockInBlockList(chain); } BlockHeader rollbackBlockHeader = chain.rollbackBlock(); List<Agent> agentList = chain.getAgentList(); List<Deposit> depositList = chain.getDepositList(); List<PunishLogPo> yellowList = chain.getYellowPunishList(); List<PunishLogPo> redPunishList = chain.getRedPunishList(); long height = rollbackBlockHeader.getHeight(); for (int i = agentList.size() - 1; i >= 0; i--) { Agent agent = agentList.get(i); if (agent.getDelHeight() == height) { agent.setDelHeight(-1L); } if (agent.getBlockHeight() == height) { agentList.remove(i); } } for (int i = depositList.size() - 1; i >= 0; i--) { Deposit deposit = depositList.get(i); if (deposit.getDelHeight() == height) { deposit.setDelHeight(-1L); } if (deposit.getBlockHeight() == height) { depositList.remove(i); } } for (int i = yellowList.size() - 1; i >= 0; i--) { PunishLogPo tempYellow = yellowList.get(i); if (tempYellow.getHeight() < height) { break; } if (tempYellow.getHeight() == height) { yellowList.remove(i); } } for (int i = redPunishList.size() - 1; i >= 0; i--) { PunishLogPo redPunish = redPunishList.get(i); if (redPunish.getHeight() < height) { break; } if (redPunish.getHeight() == height) { redPunishList.remove(i); } } roundManager.checkIsNeedReset(); return true; } ChainContainer(Chain chain); boolean addBlock(Block block); Result verifyBlock(Block block); Result verifyBlock(Block block, boolean isDownload, boolean isNeedCheckCoinBaseTx); boolean verifyCoinBaseTx(Block block, MeetingRound currentRound, MeetingMember member); boolean verifyPunishTx(Block block, MeetingRound currentRound, MeetingMember member); Result verifyAndAddBlock(Block block, boolean isDownload, boolean isNeedCheckCoinBaseTx); boolean rollback(Block block); ChainContainer getBeforeTheForkChain(ChainContainer chainContainer); ChainContainer getAfterTheForkChain(ChainContainer chainContainer); MeetingRound getCurrentRound(); MeetingRound getOrResetCurrentRound(); MeetingRound getOrResetCurrentRound(boolean isRealTime); MeetingRound initRound(); void clearRound(int count); Block getBestBlock(); Chain getChain(); void setChain(Chain chain); @Override boolean equals(Object obj); RoundManager getRoundManager(); }### Answer:
@Test public void testRollback() { testAddAgent(); assertEquals(chainContainer.getCurrentRound().getMemberCount(), 2); for (int i = 3; i > 0; i--) { Block bestBlock = chainContainer.getBestBlock(); boolean success = chainContainer.rollback(bestBlock); assert (success); } assertEquals(chainContainer.getCurrentRound().getMemberCount(), 1); } |
### Question:
ChainContainer implements Cloneable { public ChainContainer getBeforeTheForkChain(ChainContainer chainContainer) { Chain newChain = new Chain(); newChain.setId(chainContainer.getChain().getId()); newChain.initData(chain.getStartBlockHeader(), new CopyOnWriteArrayList<>(chain.getAllBlockHeaderList()), new CopyOnWriteArrayList<>(chain.getAllBlockList())); if (chain.getAgentList() != null) { List<Agent> agentList = new ArrayList<>(); for (Agent agent : chain.getAgentList()) { try { agentList.add(agent.clone()); } catch (CloneNotSupportedException e) { Log.error(e); } } newChain.setAgentList(agentList); } if (chain.getDepositList() != null) { List<Deposit> depositList = new ArrayList<>(); for (Deposit deposit : chain.getDepositList()) { try { depositList.add(deposit.clone()); } catch (CloneNotSupportedException e) { Log.error(e); } } newChain.setDepositList(depositList); } if (chain.getYellowPunishList() != null) { newChain.setYellowPunishList(new ArrayList<>(chain.getYellowPunishList())); } if (chain.getRedPunishList() != null) { newChain.setRedPunishList(new ArrayList<>(chain.getRedPunishList())); } ChainContainer newChainContainer = new ChainContainer(newChain); BlockHeader pointBlockHeader = chainContainer.getChain().getStartBlockHeader(); List<Block> blockList = newChain.getAllBlockList(); for (int i = blockList.size() - 1; i >= 0; i--) { Block block = blockList.get(i); if (pointBlockHeader.getPreHash().equals(block.getHeader().getHash())) { break; } newChainContainer.rollback(block); } newChainContainer.initRound(); return newChainContainer; } ChainContainer(Chain chain); boolean addBlock(Block block); Result verifyBlock(Block block); Result verifyBlock(Block block, boolean isDownload, boolean isNeedCheckCoinBaseTx); boolean verifyCoinBaseTx(Block block, MeetingRound currentRound, MeetingMember member); boolean verifyPunishTx(Block block, MeetingRound currentRound, MeetingMember member); Result verifyAndAddBlock(Block block, boolean isDownload, boolean isNeedCheckCoinBaseTx); boolean rollback(Block block); ChainContainer getBeforeTheForkChain(ChainContainer chainContainer); ChainContainer getAfterTheForkChain(ChainContainer chainContainer); MeetingRound getCurrentRound(); MeetingRound getOrResetCurrentRound(); MeetingRound getOrResetCurrentRound(boolean isRealTime); MeetingRound initRound(); void clearRound(int count); Block getBestBlock(); Chain getChain(); void setChain(Chain chain); @Override boolean equals(Object obj); RoundManager getRoundManager(); }### Answer:
@Test public void testGetBeforeTheForkChain() { Block forkBlock = null; for (int i = 0; i < 20; i++) { Block bestBlock = chainContainer.getBestBlock(); Block newBlock = newBlock(bestBlock); Result success = chainContainer.verifyAndAddBlock(newBlock, false, true); assertTrue(success.isSuccess()); bestBlock = chainContainer.getBestBlock(); assertEquals(bestBlock.getHeader().getHeight(), 1L + i); if (i == 10) { forkBlock = bestBlock; } } Chain chain = new Chain(); chain.addBlock(forkBlock); Block newBlock = newBlock(forkBlock); chain.addBlock(newBlock); ChainContainer otherChainContainer = new ChainContainer(chain); ChainContainer newForkChainContainer = chainContainer.getBeforeTheForkChain(otherChainContainer); assertEquals(newForkChainContainer.getBestBlock().getHeader().getHeight(), 10L); } |
### Question:
ChainContainer implements Cloneable { public ChainContainer getAfterTheForkChain(ChainContainer chainContainer) { BlockHeader pointBlockHeader = chainContainer.getChain().getStartBlockHeader(); Chain chain = new Chain(); List<Block> blockList = getChain().getAllBlockList(); boolean canAdd = false; for (int i = 0; i < blockList.size(); i++) { Block block = blockList.get(i); if (canAdd) { chain.addBlock(block); } if (pointBlockHeader.getPreHash().equals(block.getHeader().getHash())) { canAdd = true; chain.setPreChainId(getChain().getId()); continue; } } return new ChainContainer(chain); } ChainContainer(Chain chain); boolean addBlock(Block block); Result verifyBlock(Block block); Result verifyBlock(Block block, boolean isDownload, boolean isNeedCheckCoinBaseTx); boolean verifyCoinBaseTx(Block block, MeetingRound currentRound, MeetingMember member); boolean verifyPunishTx(Block block, MeetingRound currentRound, MeetingMember member); Result verifyAndAddBlock(Block block, boolean isDownload, boolean isNeedCheckCoinBaseTx); boolean rollback(Block block); ChainContainer getBeforeTheForkChain(ChainContainer chainContainer); ChainContainer getAfterTheForkChain(ChainContainer chainContainer); MeetingRound getCurrentRound(); MeetingRound getOrResetCurrentRound(); MeetingRound getOrResetCurrentRound(boolean isRealTime); MeetingRound initRound(); void clearRound(int count); Block getBestBlock(); Chain getChain(); void setChain(Chain chain); @Override boolean equals(Object obj); RoundManager getRoundManager(); }### Answer:
@Test public void testGetAfterTheForkChain() { Block forkBlock = null; for (int i = 0; i < 30; i++) { Block bestBlock = chainContainer.getBestBlock(); Block newBlock = newBlock(bestBlock); Result success = chainContainer.verifyAndAddBlock(newBlock, false, true); assertTrue(success.isSuccess()); bestBlock = chainContainer.getBestBlock(); assertEquals(bestBlock.getHeader().getHeight(), 1L + i); if (i == 20) { forkBlock = bestBlock; } } Chain chain = new Chain(); chain.addBlock(forkBlock); Block newBlock = newBlock(forkBlock); chain.addBlock(newBlock); ChainContainer otherChainContainer = new ChainContainer(chain); ChainContainer newForkChainContainer = chainContainer.getAfterTheForkChain(otherChainContainer); assertEquals(newForkChainContainer.getBestBlock().getHeader().getHeight(), 30L); } |
### Question:
MicroKernelBootstrap extends BaseModuleBootstrap { @Override public void init() { String folder = null; try { NulsConfig.NULS_CONFIG = ConfigLoader.loadIni(NulsConstant.USER_CONFIG_FILE); String mode = NulsConfig.NULS_CONFIG.getCfgValue(NulsConstant.CFG_SYSTEM_SECTION, "mode", "main"); if ("main".equals(mode)) { NulsConfig.MODULES_CONFIG = ConfigLoader.loadIni(NulsConstant.MODULES_CONFIG_FILE); } else { NulsConfig.MODULES_CONFIG = ConfigLoader.loadIni(mode + "/" + NulsConstant.MODULES_CONFIG_FILE); } } catch (Exception e) { Log.error("Client start failed", e); throw new RuntimeException("Client start failed"); } TimeService.getInstance().start(); try { NulsConfig.DEFAULT_ENCODING = NulsConfig.NULS_CONFIG.getCfgValue(NulsConstant.CFG_SYSTEM_SECTION, NulsConstant.CFG_SYSTEM_DEFAULT_ENCODING); String language = NulsConfig.NULS_CONFIG.getCfgValue(NulsConstant.CFG_SYSTEM_SECTION, NulsConstant.CFG_SYSTEM_LANGUAGE); I18nUtils.setLanguage(language); String chainId = NulsConfig.NULS_CONFIG.getCfgValue(NulsConstant.CFG_SYSTEM_SECTION, NulsConstant.CFG_SYSTEM_DEFAULT_CHAIN_ID, "8964"); NulsContext.getInstance().setDefaultChainId(Short.parseShort(chainId)); } catch (Exception e) { Log.error(e); } SpringLiteContext.init("io.nuls", new ModularServiceMethodInterceptor()); try { NulsConfig.VERSION = getKernelVersion(); TransactionManager.init(); ValidatorManager.init(); } catch (Exception e) { Log.error(e); } } private MicroKernelBootstrap(); static MicroKernelBootstrap getInstance(); @Override void init(); @Override void start(); @Override void shutdown(); @Override void destroy(); @Override String getInfo(); }### Answer:
@Test public void init() { bootstrap.init(); assertNotNull(NulsConfig.MODULES_CONFIG); assertNotNull(NulsConfig.NULS_CONFIG); assertTrue(SpringLiteContext.isInitSuccess()); assertNotNull(NulsConfig.VERSION); assertNotNull(ValidatorManager.isInitSuccess()); } |
### Question:
NulsDigestData extends BaseNulsData { public static NulsDigestData calcDigestData(BaseNulsData data) { return calcDigestData(data, (byte) 0); } NulsDigestData(); NulsDigestData(byte algType, byte[] bytes); @Override int size(); @Override void parse(NulsByteBuffer byteBuffer); byte getDigestAlgType(); void setDigestAlgType(byte digestAlgType); String getDigestHex(); static NulsDigestData fromDigestHex(String hex); static boolean validHash(String hex); static NulsDigestData calcDigestData(BaseNulsData data); static NulsDigestData calcDigestData(BaseNulsData data, byte digestAlgType); byte[] getDigestBytes(); static NulsDigestData calcDigestData(byte[] data); static NulsDigestData calcDigestData(byte[] data, byte digestAlgType); static NulsDigestData calcMerkleDigestData(List<NulsDigestData> ddList); @Override boolean equals(Object obj); @Override String toString(); @Override int hashCode(); static final int HASH_LENGTH; static byte DIGEST_ALG_SHA256; static byte DIGEST_ALG_SHA160; }### Answer:
@Test public void test() { NulsDigestData hash = NulsDigestData.calcDigestData(new byte[32]); System.out.println(hash); assertTrue(true); } |
### Question:
MessageBusServiceImpl implements MessageBusService { @Override public String subscribeMessage(Class<? extends BaseMessage> messageClass, NulsMessageHandler<? extends BaseMessage> messageHandler) { MessageManager.putMessage(messageClass); return handlerManager.registerMessageHandler(null, messageClass, messageHandler); } @Override String subscribeMessage(Class<? extends BaseMessage> messageClass, NulsMessageHandler<? extends BaseMessage> messageHandler); @Override void unsubscribeMessage(String subscribeId); @Override void receiveMessage(BaseMessage message, Node node); void shutdown(); @Override Result<List<String>> broadcast(BaseMessage message, Node excludeNode, boolean aysn, int percent); @Override Result sendToNode(BaseMessage message, Node node, boolean aysn); @Override Result<? extends BaseMessage> getMessageInstance(short moduleId, int type); }### Answer:
@Test public void subscribeMessage() throws Exception { subscribe(); assertNotNull(handlerId); Field field = messageBusService.getClass().getDeclaredField("processorManager"); field.setAccessible(true); DispatchManager processorManager = (DispatchManager) field.get(messageBusService); Class processorManagerClass = processorManager.getClass(); Field handlerMapField = processorManagerClass.getDeclaredField("handlerMap"); handlerMapField.setAccessible(true); Map<String, NulsMessageHandler> handlerMap = (Map<String, NulsMessageHandler>) handlerMapField.get(processorManager); assertNotNull(handlerMap.get(handlerId)); assertEquals(handlerMap.get(handlerId), messageHandler); Field messageHandlerMappingField = processorManagerClass.getDeclaredField("messageHandlerMapping"); messageHandlerMappingField.setAccessible(true); Map<Class, Set<String>> messageHandlerMapping = (Map<Class, Set<String>>) messageHandlerMappingField.get(processorManager); assertNotNull(messageHandlerMapping.get(block)); assertTrue(messageHandlerMapping.get(block).contains(handlerId)); } |
### Question:
MessageBusServiceImpl implements MessageBusService { @Override public void unsubscribeMessage(String subscribeId) { this.handlerManager.removeMessageHandler(subscribeId); } @Override String subscribeMessage(Class<? extends BaseMessage> messageClass, NulsMessageHandler<? extends BaseMessage> messageHandler); @Override void unsubscribeMessage(String subscribeId); @Override void receiveMessage(BaseMessage message, Node node); void shutdown(); @Override Result<List<String>> broadcast(BaseMessage message, Node excludeNode, boolean aysn, int percent); @Override Result sendToNode(BaseMessage message, Node node, boolean aysn); @Override Result<? extends BaseMessage> getMessageInstance(short moduleId, int type); }### Answer:
@Test public void unsubscribeMessage() throws Exception { messageBusService.unsubscribeMessage(handlerId); Field field = messageBusService.getClass().getDeclaredField("processorManager"); field.setAccessible(true); DispatchManager processorManager = (DispatchManager) field.get(messageBusService); Class processorManagerClass = processorManager.getClass(); Field handlerMapField = processorManagerClass.getDeclaredField("handlerMap"); handlerMapField.setAccessible(true); Map<String, NulsMessageHandler> handlerMap = (Map<String, NulsMessageHandler>) handlerMapField.get(processorManager); assertNull(handlerMap.get(handlerId)); } |
### Question:
MessageBusServiceImpl implements MessageBusService { @Override public void receiveMessage(BaseMessage message, Node node) { try { this.processorManager.offer(new ProcessData(message, node)); } catch (Exception e) { Log.error(e); } } @Override String subscribeMessage(Class<? extends BaseMessage> messageClass, NulsMessageHandler<? extends BaseMessage> messageHandler); @Override void unsubscribeMessage(String subscribeId); @Override void receiveMessage(BaseMessage message, Node node); void shutdown(); @Override Result<List<String>> broadcast(BaseMessage message, Node excludeNode, boolean aysn, int percent); @Override Result sendToNode(BaseMessage message, Node node, boolean aysn); @Override Result<? extends BaseMessage> getMessageInstance(short moduleId, int type); }### Answer:
@Test public void receiveMessage() { BlockMessage blockMessage = new BlockMessage(); Node node = new Node("192.168.1.90",8003,1); messageBusService.receiveMessage(blockMessage, node); } |
### Question:
MessageBusServiceImpl implements MessageBusService { @Override public Result<List<String>> broadcast(BaseMessage message, Node excludeNode, boolean aysn, int percent) { BroadcastResult result = networkService.sendToAllNode(message, excludeNode, aysn, percent); return getNodeIdListResult(result); } @Override String subscribeMessage(Class<? extends BaseMessage> messageClass, NulsMessageHandler<? extends BaseMessage> messageHandler); @Override void unsubscribeMessage(String subscribeId); @Override void receiveMessage(BaseMessage message, Node node); void shutdown(); @Override Result<List<String>> broadcast(BaseMessage message, Node excludeNode, boolean aysn, int percent); @Override Result sendToNode(BaseMessage message, Node node, boolean aysn); @Override Result<? extends BaseMessage> getMessageInstance(short moduleId, int type); }### Answer:
@Test public void broadcastAndCache() { BlockMessage blockMessage = new BlockMessage(); Node node = new Node("192.168.1.90",8003,1); boolean aysn = true; Result<List<String>> result = messageBusService.broadcast(blockMessage, node, aysn,100); assertTrue(result.isSuccess()); assertTrue(result.getData().size()>0); } |
### Question:
TemporaryCacheManager { public void destroy() { this.smallBlockCacheMap.clear(); this.txCacheMap.clear(); } private TemporaryCacheManager(); static TemporaryCacheManager getInstance(); void cacheSmallBlock(SmallBlock smallBlock); void cacheSmallBlockWithRequest(NulsDigestData requestHash, SmallBlock smallBlock); SmallBlock getSmallBlockByRequest(NulsDigestData requestHash); SmallBlock getSmallBlockByHash(NulsDigestData blockHash); boolean cacheTx(Transaction tx); Transaction getTx(NulsDigestData hash); void removeSmallBlock(NulsDigestData hash); void clear(); void destroy(); boolean containsTx(NulsDigestData txHash); int getSmallBlockCount(); int getTxCount(); }### Answer:
@Test public void destroy() { manager.destroy(); assertNull(EhCacheManager.getInstance().getCache("temp-small-block-cache")); assertNull(EhCacheManager.getInstance().getCache("temp-tx-cache")); } |
### Question:
MessageBusServiceImpl implements MessageBusService { @Override public Result sendToNode(BaseMessage message, Node node, boolean aysn) { BroadcastResult result = networkService.sendToNode(message, node, aysn); if (!result.isSuccess()) { Log.error("send to node fail reason: " + result.getErrorCode().getMsg() + "::::" + node.getId()); } return new Result(result.isSuccess(), result.getErrorCode(), null); } @Override String subscribeMessage(Class<? extends BaseMessage> messageClass, NulsMessageHandler<? extends BaseMessage> messageHandler); @Override void unsubscribeMessage(String subscribeId); @Override void receiveMessage(BaseMessage message, Node node); void shutdown(); @Override Result<List<String>> broadcast(BaseMessage message, Node excludeNode, boolean aysn, int percent); @Override Result sendToNode(BaseMessage message, Node node, boolean aysn); @Override Result<? extends BaseMessage> getMessageInstance(short moduleId, int type); }### Answer:
@Test public void sendToNode() { BlockMessage blockMessage = new BlockMessage(); Node node = new Node("192.168.1.90",8003,1); boolean aysn = true; assertTrue(messageBusService.sendToNode(blockMessage, node, aysn).isSuccess()); } |
### Question:
MessageBusModuleBootstrap extends AbstractMessageBusModule { @Override public void start() { DispatchManager.getInstance().init(true); } @Override void init(); @Override void start(); @Override void shutdown(); @Override void destroy(); @Override String getInfo(); }### Answer:
@Test public void start() { messageBusModuleBootstrap.start(); } |
### Question:
MessageBusModuleBootstrap extends AbstractMessageBusModule { @Override public void shutdown() { DispatchManager.getInstance().shutdown(); } @Override void init(); @Override void start(); @Override void shutdown(); @Override void destroy(); @Override String getInfo(); }### Answer:
@Test public void shutdown() { messageBusModuleBootstrap.shutdown(); } |
### Question:
MessageBusModuleBootstrap extends AbstractMessageBusModule { @Override public void destroy() { } @Override void init(); @Override void start(); @Override void shutdown(); @Override void destroy(); @Override String getInfo(); }### Answer:
@Test public void destroy() { messageBusModuleBootstrap.destroy(); } |
### Question:
AccountBaseService { public Result getPrivateKey(String address, String password) { if (!AddressTool.validAddress(address)) { return Result.getFailed(AccountErrorCode.ADDRESS_ERROR); } Account account = accountService.getAccount(address).getData(); if (null == account) { return Result.getFailed(AccountErrorCode.ACCOUNT_NOT_EXIST); } if (account.isEncrypted()) { try { byte[] priKeyBytes = priKeyBytes = account.getPriKey(password); return Result.getSuccess().setData(Hex.encode(priKeyBytes)); } catch (NulsException e) { return Result.getFailed(AccountErrorCode.PASSWORD_IS_WRONG); } } return Result.getFailed(AccountErrorCode.ACCOUNT_UNENCRYPTED); } Result setRemark(String address, String remark); Result getPrivateKey(String address, String password); Result getAllPrivateKey(String password); Result getAllPrivateKey(); Result setPassword(String address, String password); Result changePassword(String address, String oldPassword, String newPassword); }### Answer:
@Test public void getPrivateKeyTest() { List<Account> accounts = this.accountService.createAccount(1, "nuls123456").getData(); Account account = accounts.get(0); Result result = accountBaseService.getPrivateKey(account.getAddress().toString(), "nuls123456"); assertTrue(result.isSuccess()); try { account.unlock("nuls123456"); } catch (NulsException e) { e.printStackTrace(); } assertArrayEquals(Hex.decode((String)result.getData()), account.getPriKey()); List<Account> accounts2 = this.accountService.createAccount(1, "").getData(); Account account2 = accounts2.get(0); Result result2 = accountBaseService.getPrivateKey(account2.getAddress().toString(), ""); assertTrue(result2.isSuccess()); assertArrayEquals(Hex.decode((String)result2.getData()), account2.getPriKey()); } |
### Question:
AccountBaseService { public Result setPassword(String address, String password) { if (!AddressTool.validAddress(address)) { return Result.getFailed(AccountErrorCode.ADDRESS_ERROR); } if (StringUtils.isBlank(password)) { return Result.getFailed(AccountErrorCode.NULL_PARAMETER); } if (!StringUtils.validPassword(password)) { return Result.getFailed(AccountErrorCode.PASSWORD_FORMAT_WRONG); } Account account = accountService.getAccount(address).getData(); if (null == account) { return Result.getFailed(AccountErrorCode.ACCOUNT_NOT_EXIST); } if (account.isEncrypted()) { return Result.getFailed(AccountErrorCode.ACCOUNT_IS_ALREADY_ENCRYPTED); } try { account.encrypt(password); Result result = accountStorageService.updateAccount(new AccountPo(account)); if (result.isFailed()) { return Result.getFailed(AccountErrorCode.FAILED); } accountCacheService.localAccountMaps.put(account.getAddress().getBase58(), account); } catch (NulsException e) { Log.error(e); return Result.getFailed(AccountErrorCode.FAILED); } return Result.getSuccess().setData(true); } Result setRemark(String address, String remark); Result getPrivateKey(String address, String password); Result getAllPrivateKey(String password); Result getAllPrivateKey(); Result setPassword(String address, String password); Result changePassword(String address, String oldPassword, String newPassword); }### Answer:
@Test public void setPassword() { List<Account> accounts = this.accountService.createAccount(1, "").getData(); Account account = accounts.get(0); accountBaseService.setPassword(account.getAddress().toString(),"nuls123456"); Account acc = accountService.getAccount(account.getAddress()).getData(); try { assertTrue(acc.unlock("nuls123456")); assertArrayEquals(acc.getPriKey(), account.getPriKey()); } catch (NulsException e) { e.printStackTrace(); } } |
### Question:
AccountBaseService { public Result changePassword(String address, String oldPassword, String newPassword) { if (!AddressTool.validAddress(address)) { return Result.getFailed(AccountErrorCode.ADDRESS_ERROR); } if (StringUtils.isBlank(oldPassword)) { return Result.getFailed(AccountErrorCode.PARAMETER_ERROR); } if (StringUtils.isBlank(newPassword)) { return Result.getFailed(AccountErrorCode.PARAMETER_ERROR); } if (!StringUtils.validPassword(oldPassword)) { return Result.getFailed(AccountErrorCode.PASSWORD_FORMAT_WRONG); } if (!StringUtils.validPassword(newPassword)) { return Result.getFailed(AccountErrorCode.PASSWORD_FORMAT_WRONG); } Account account = accountService.getAccount(address).getData(); if (null == account) { return Result.getFailed(AccountErrorCode.ACCOUNT_NOT_EXIST); } try { if (!account.isEncrypted()) { return Result.getFailed(AccountErrorCode.ACCOUNT_UNENCRYPTED); } if (!account.validatePassword(oldPassword)) { return Result.getFailed(AccountErrorCode.PASSWORD_IS_WRONG); } account.unlock(oldPassword); account.encrypt(newPassword, true); AccountPo po = new AccountPo(account); Result result = accountStorageService.updateAccount(po); if (result.isFailed()) { return Result.getFailed(AccountErrorCode.FAILED); } accountCacheService.localAccountMaps.put(account.getAddress().getBase58(), account); return result.setData(true); } catch (NulsException e) { Log.error(e); return Result.getFailed(e.getErrorCode()); } } Result setRemark(String address, String remark); Result getPrivateKey(String address, String password); Result getAllPrivateKey(String password); Result getAllPrivateKey(); Result setPassword(String address, String password); Result changePassword(String address, String oldPassword, String newPassword); }### Answer:
@Test public void changePassword() { List<Account> accounts = this.accountService.createAccount(1, "nuls123456").getData(); Account account = accounts.get(0); accountBaseService.changePassword(account.getAddress().toString(),"nuls123456", "nuls111111"); Account acc = accountService.getAccount(account.getAddress()).getData(); try { assertFalse(acc.unlock("nuls123456")); assertTrue(acc.unlock("nuls111111")); assertArrayEquals(acc.getPriKey(), account.getPriKey()); } catch (NulsException e) { } } |
### Question:
AliasService { public Result saveAlias(AliasPo aliaspo) throws NulsException { try { Result result = aliasStorageService.saveAlias(aliaspo); if (result.isFailed()) { this.rollbackAlias(aliaspo); } AccountPo po = accountStorageService.getAccount(aliaspo.getAddress()).getData(); if (null != po) { po.setAlias(aliaspo.getAlias()); Result resultAcc = accountStorageService.updateAccount(po); if (resultAcc.isFailed()) { this.rollbackAlias(aliaspo); } Account account = po.toAccount(); accountCacheService.localAccountMaps.put(account.getAddress().getBase58(), account); } } catch (Exception e) { this.rollbackAlias(aliaspo); Log.error(e); return Result.getFailed(AccountErrorCode.FAILED); } return Result.getSuccess().setData(true); } Result<String> setAlias(String addr, String aliasName, String password); Result saveAlias(AliasPo aliaspo); Alias getAlias(String alias); boolean isAliasUsable(String alias); Result rollbackAlias(AliasPo aliasPo); Result<Na> getAliasFee(String address, String aliasName); Result<Na> getMultiAliasFee(String address, String aliasName); Result<String> setMutilAlias(String addr, String signAddr, String aliasName, String password, List<String> pubKeys, int m, String txdata); Result<String> setMutilAlias(String addr, String signAddr, String aliasName, String password); Result signMultiAliasTransaction(String signAddr, String password, String txdata); boolean isMutilAliasUsable(byte[] address, String aliasName); Result<String> txMutilProcessing(Transaction tx, List<P2PHKSignature> p2PHKSignatures, List<Script> scripts, TransactionSignature transactionSignature, byte[] fromAddr); List<AliasPo> getAllAlias(); }### Answer:
@Test public void saveAlias() { List<Account> accounts = accountService.createAccount(1, "nuls123456").getData(); Account account = accounts.get(0); Alias alias = new Alias(account.getAddress().getAddressBytes(), "lichao"); try { assertTrue(aliasService.saveAlias(new AliasPo(alias)).isSuccess()); } catch (NulsException e) { e.printStackTrace(); } } |
### Question:
CallContractData extends TransactionLogicData implements ContractData { public String[][] getArgs() { return args; } @Override int size(); @Override void parse(NulsByteBuffer byteBuffer); @Override byte[] getSender(); void setSender(byte[] sender); @Override byte[] getContractAddress(); void setContractAddress(byte[] contractAddress); @Override long getValue(); void setValue(long value); @Override long getGasLimit(); void setGasLimit(long gasLimit); @Override long getPrice(); void setPrice(long price); String getMethodName(); void setMethodName(String methodName); String getMethodDesc(); void setMethodDesc(String methodDesc); byte getArgsCount(); void setArgsCount(byte argsCount); String[][] getArgs(); void setArgs(String[][] args); @Override Set<byte[]> getAddresses(); }### Answer:
@Test public void test1() { try { byte[] key = LedgerUtil.asBytes("aasdasdasdasda"); dbService.putModel(area, key, data); CallContractData dataConvert = dbService.getModel(area, key, CallContractData.class); System.out.println(dataConvert.toString()); String[][] strings = dataConvert.getArgs(); for(String[] bbb : strings) System.out.println(Arrays.toString(bbb)); } catch (Exception e) { e.printStackTrace(); Assert.fail(); } } |
### Question:
ECKey { public static ECKey signedMessageToKey(String message, String signatureBase64) throws SignatureException { byte[] signatureEncoded; try { signatureEncoded = Base64.decode(signatureBase64); } catch (RuntimeException e) { throw new SignatureException("Could not decode base64", e); } if (signatureEncoded.length < 65) throw new SignatureException("Signature truncated, expected 65 bytes and got " + signatureEncoded.length); int header = signatureEncoded[0] & 0xFF; if (header < 27 || header > 34) throw new SignatureException("Header byte out of range: " + header); BigInteger r = new BigInteger(1, Arrays.copyOfRange(signatureEncoded, 1, 33)); BigInteger s = new BigInteger(1, Arrays.copyOfRange(signatureEncoded, 33, 65)); ECDSASignature sig = new ECDSASignature(r, s); byte[] messageBytes = formatMessageForSigning(message); Sha256Hash messageHash = Sha256Hash.twiceOf(messageBytes); boolean compressed = false; if (header >= 31) { compressed = true; header -= 4; } int recId = header - 27; ECKey key = ECKey.recoverFromSignature(recId, sig, messageHash, compressed); if (key == null) throw new SignatureException("Could not recover public key from signature"); return key; } ECKey(); ECKey(SecureRandom secureRandom); private ECKey(BigInteger priv, ECPoint pub); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(BigInteger privKey, boolean compressed); static ECKey fromPublicOnly(byte[] pubKey); static ECKey fromPublicOnly(ECPoint pub); static ECPoint publicPointFromPrivate(BigInteger privKey); static ECKey fromEncrypted(EncryptedData encryptedPrivateKey, byte[] pubKey); byte[] getPubKey(); @JsonIgnore BigInteger getPrivKey(); @JsonIgnore byte[] getPrivKeyBytes(); @JsonIgnore String getPrivateKeyAsHex(); String getPublicKeyAsHex(); String getPublicKeyAsHex(boolean compressed); static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); static boolean verify(byte[] data, byte[] signature, byte[] pub); boolean verify(byte[] hash, byte[] signature); byte[] sign(byte[] hash); byte[] sign(Sha256Hash hash, BigInteger aesKey); byte[] sign(byte[] hash, BigInteger aesKey); boolean hasPrivKey(); boolean isCompressed(); void setCreationTimeSeconds(long creationTimeSeconds); long getCreationTimeSeconds(); EncryptedData getEncryptedPrivateKey(); void setEncryptedPrivateKey(EncryptedData encryptedPrivateKey); static boolean isValidPrivteHex(String privateHex); static ECKey signedMessageToKey(String message, String signatureBase64); @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, Sha256Hash message, boolean compressed); String signMessage(String message, @Nullable KeyParameter aesKey); byte findRecoveryId(Sha256Hash hash, ECDSASignature sig); static final ECDomainParameters CURVE; static final BigInteger HALF_CURVE_ORDER; static final Comparator<ECKey> PUBKEY_COMPARATOR; }### Answer:
@Test public void signedMessageToKeyTest() throws SignatureException { ECKey key = new ECKey(); System.out.println(key.getPrivateKeyAsHex()); System.out.println(key.getPublicKeyAsHex()); String message = "Nuls Signed Message:\nHello,I'am test case！@##$%998877"; String signatureBase64 = key.signMessage(message,null); System.out.println(signatureBase64); System.out.println(Base64.decode(signatureBase64).length); ECKey recoveryECKey = ECKey.signedMessageToKey(message, signatureBase64); Assert.assertEquals(recoveryECKey.getPublicKeyAsHex(),key.getPublicKeyAsHex()); } |
### Question:
VersionUtils { public static boolean higherThan(String version0, String version1) { if (StringUtils.isBlank(version0) || StringUtils.isBlank(version1)) { throw new RuntimeException("version is null"); } Integer[] intArr0 = strArrayToInt(version0); Integer[] intArr1 = strArrayToInt(version1); boolean result = false; for (int i = 0; i < intArr0.length; i++) { Integer val1 = intArr0[i]; if (intArr1.length <= i && val1 > 0) { result = true; break; } Integer val2 = intArr1[i]; if (val1 > val2) { result = true; break; } } if (!result && intArr1.length > intArr0.length) { result = intArr1[intArr0.length] > 0; } return result; } static boolean higherThan(String version0, String version1); static boolean equalsWith(String version0, String version1); static boolean lowerThan(String version0, String version1); }### Answer:
@Test public void higherThan() { String v1 = "1.1.0"; String v2 = "1.1.0-beta"; String v3 = "1.1.1"; String v4 = "1.1.1-beta1"; String v5 = "1.1.1-beta2"; String v6 = "1.1.2-beta1"; String v7 = "1.2.0"; assertTrue(!VersionUtils.higherThan(v2, v1)); assertTrue(VersionUtils.higherThan(v3, v2)); assertTrue(VersionUtils.higherThan(v4, v3)); assertTrue(VersionUtils.higherThan(v5, v4)); assertTrue(VersionUtils.higherThan(v6, v5)); assertTrue(VersionUtils.higherThan(v7, v1)); assertTrue(VersionUtils.higherThan(v7, v2)); assertTrue(VersionUtils.higherThan(v7, v6)); assertTrue(VersionUtils.lowerThan(v2, v3)); assertTrue(VersionUtils.lowerThan(v3, v4)); assertTrue(VersionUtils.lowerThan(v4, v5)); assertTrue(VersionUtils.lowerThan(v5, v6)); assertTrue(VersionUtils.lowerThan(v1, v7)); assertTrue(VersionUtils.lowerThan(v2, v7)); assertTrue(VersionUtils.lowerThan(v6, v7)); assertTrue(!VersionUtils.lowerThan(v2, v1)); assertTrue(VersionUtils.equalsWith(v1, v2)); } |
### Question:
FileUtil { public static boolean deleteFolder(File folder) { if (!folder.exists()) { return true; } File[] files = folder.listFiles(); for (File file : files) { if (file.isFile()) { try { boolean b = file.delete(); if (!b) { Log.info("delete " + file.getName() + " result:" + b); mkNullToFile(file); } } catch (Exception e) { Log.error(e); } } else { deleteFolder(file); } } try { boolean b = folder.delete(); } catch (Exception e) { Log.error(e); } return true; } static File compress(File source, File target); static void decompress(String zipPath, String targetPath); static void copyFile(File source, File target); static void copyFolder(File source, File target); static void writeText(String text, String path); static boolean writeFile(byte[] bytes, String filePath); static boolean deleteFolder(File folder); static void deleteFolder(String path); }### Answer:
@Test public void deleteFolder() { FileUtil.deleteFolder("C:\\Users\\Administrator\\Desktop\\release\\NULS-Wallet-0.9.10-windows-x64-for-test\\conf\\client-web"); } |
### Question:
UpgradeThread implements Runnable { private boolean download(String url, String filePath, String signature) throws IOException { if (!upgrading) { setFailedMessage("The upgrade has stopped"); return false; } byte[] bytes = HttpDownloadUtils.download(url); if (!verifySig(bytes, Hex.decode(signature))) { setFailedMessage("Signature verification is incorrect:" + url); return false; } boolean result = FileUtil.writeFile(bytes, filePath); if (!result) { setFailedMessage("Write file failed:" + filePath); } return result; } private UpgradeThread(); static UpgradeThread getInstance(); @Override void run(); boolean start(); boolean stop(); boolean isUpgrading(); UpgradeProcessDTO getProcess(); }### Answer:
@Test public void download() { System.out.print("abcdefg"); System.out.print("\b"); System.out.print("\b"); System.out.print("\b"); } |
### Question:
PoConvertUtil { public static String getAgentId(NulsDigestData hash) { String hashHex = hash.getDigestHex(); return hashHex.substring(hashHex.length() - 8).toUpperCase(); } static Agent poToAgent(AgentPo agentPo); static AgentPo agentToPo(Agent agent); static Deposit poToDeposit(DepositPo po); static DepositPo depositToPo(Deposit deposit); static String getAgentId(NulsDigestData hash); }### Answer:
@Test public void getAgentId() { NulsDigestData hash = NulsDigestData.calcDigestData("123123".getBytes()); System.out.println(PoConvertUtil.getAgentId(hash)); System.out.println(hash); assertTrue(true); } |
### Question:
ChainManager { public void newOrphanChain(Block block) { Chain orphanChain = new Chain(); orphanChain.initData(block); ChainContainer orphanChainContainer = new ChainContainer(orphanChain); orphanChains.add(orphanChainContainer); } ChainManager(); void newOrphanChain(Block block); boolean checkIsBeforeOrphanChainAndAdd(Block block); boolean checkIsAfterOrphanChainAndAdd(Block block); long getBestBlockHeight(); void clear(); ChainContainer getMasterChain(); void setMasterChain(ChainContainer masterChain); List<ChainContainer> getChains(); Block getBestBlock(); List<ChainContainer> getOrphanChains(); }### Answer:
@Test public void testNewOrphanChain() { assertNotNull(chainManager); Block block = createBlock(); chainManager.newOrphanChain(block); assertEquals(1, chainManager.getOrphanChains().size()); } |
### Question:
ChainManager { public long getBestBlockHeight() { if(masterChain == null || masterChain.getChain() == null || masterChain.getChain().getEndBlockHeader() == null) { return 0L; } return masterChain.getChain().getEndBlockHeader().getHeight(); } ChainManager(); void newOrphanChain(Block block); boolean checkIsBeforeOrphanChainAndAdd(Block block); boolean checkIsAfterOrphanChainAndAdd(Block block); long getBestBlockHeight(); void clear(); ChainContainer getMasterChain(); void setMasterChain(ChainContainer masterChain); List<ChainContainer> getChains(); Block getBestBlock(); List<ChainContainer> getOrphanChains(); }### Answer:
@Test public void testGetBestBlockHeight() { assertNotNull(chainManager); Block block = createBlock(); ChainContainer masterChain = new ChainContainer(new Chain()); chainManager.setMasterChain(masterChain); masterChain.getChain().addBlock(block); assertEquals(0L, chainManager.getBestBlockHeight()); } |
### Question:
ChainManager { public boolean checkIsBeforeOrphanChainAndAdd(Block block) { BlockHeader header = block.getHeader(); boolean success = false; for(ChainContainer chainContainer : orphanChains) { Chain chain = chainContainer.getChain(); if(header.getHash().equals(chain.getStartBlockHeader().getPreHash())) { success = true; chain.addPreBlock(block); } } return success; } ChainManager(); void newOrphanChain(Block block); boolean checkIsBeforeOrphanChainAndAdd(Block block); boolean checkIsAfterOrphanChainAndAdd(Block block); long getBestBlockHeight(); void clear(); ChainContainer getMasterChain(); void setMasterChain(ChainContainer masterChain); List<ChainContainer> getChains(); Block getBestBlock(); List<ChainContainer> getOrphanChains(); }### Answer:
@Test public void testCheckIsBeforeOrphanChainAndAdd() { testGetBestBlockHeight(); Block block = createBlock(); Block block1 = createBlock(); block1.getHeader().setHeight(1L); block1.getHeader().setPreHash(block.getHeader().getHash()); ChainContainer orphanChain = new ChainContainer(new Chain()); orphanChain.getChain().addBlock(block1); chainManager.getOrphanChains().add(orphanChain); assertEquals(1, chainManager.getOrphanChains().size()); boolean success = chainManager.checkIsBeforeOrphanChainAndAdd(block); assertTrue(success); } |
### Question:
ChainManager { public boolean checkIsAfterOrphanChainAndAdd(Block block) { BlockHeader header = block.getHeader(); for(ChainContainer chainContainer : orphanChains) { Chain chain = chainContainer.getChain(); if(header.getPreHash().equals(chain.getEndBlockHeader().getHash())) { chain.addBlock(block); return true; } } return false; } ChainManager(); void newOrphanChain(Block block); boolean checkIsBeforeOrphanChainAndAdd(Block block); boolean checkIsAfterOrphanChainAndAdd(Block block); long getBestBlockHeight(); void clear(); ChainContainer getMasterChain(); void setMasterChain(ChainContainer masterChain); List<ChainContainer> getChains(); Block getBestBlock(); List<ChainContainer> getOrphanChains(); }### Answer:
@Test public void testCheckIsAfterOrphanChainAndAdd() { testGetBestBlockHeight(); Block block = createBlock(); Block block1 = createBlock(); block1.getHeader().setHeight(1L); block1.getHeader().setPreHash(block.getHeader().getHash()); ChainContainer orphanChain = new ChainContainer(new Chain()); orphanChain.getChain().addBlock(block); chainManager.getOrphanChains().add(orphanChain); assertEquals(1, chainManager.getOrphanChains().size()); boolean success = chainManager.checkIsAfterOrphanChainAndAdd(block1); assertTrue(success); } |
### Question:
RoundManager { public void addRound(MeetingRound meetingRound) { roundList.add(meetingRound); } RoundManager(Chain chain); MeetingRound getRoundByIndex(long roundIndex); void addRound(MeetingRound meetingRound); void checkIsNeedReset(); boolean clearRound(int count); MeetingRound getCurrentRound(); MeetingRound initRound(); MeetingRound resetRound(boolean isRealTime); MeetingRound getNextRound(BlockExtendsData roundData, boolean isRealTime); Chain getChain(); List<MeetingRound> getRoundList(); AccountService getAccountService(); }### Answer:
@Test public void testAddRound() { assertNotNull(roundManager); assertNotNull(roundManager.getChain()); assertEquals(0, roundManager.getRoundList().size()); MeetingRound round = new MeetingRound(); roundManager.addRound(round); assertEquals(1, roundManager.getRoundList().size()); assertEquals(round, roundManager.getCurrentRound()); MeetingRound round2 = new MeetingRound(); roundManager.addRound(round2); assertEquals(2, roundManager.getRoundList().size()); assertNotEquals(round, roundManager.getCurrentRound()); assertEquals(round2, roundManager.getCurrentRound()); } |
### Question:
Attribute implements Cloneable, Matchable<Attribute<?>> { public T get() { return value; } Attribute(AttributeDefinition<T> definition); String name(); T get(); T getInitialValue(); void validate(); Attribute<T> protect(); void set(T value); T computeIfAbsent(Supplier<T> supplier); boolean isImmutable(); boolean isPersistent(); boolean isModified(); K asObject(); void addListener(AttributeListener<T> listener); void removeListener(AttributeListener<T> listener); boolean isNull(); AttributeDefinition<T> getAttributeDefinition(); void read(Attribute<T> other); @Override int hashCode(); @Override boolean equals(Object obj); boolean matches(Attribute<?> other); @Override String toString(); void reset(); }### Answer:
@Test public void testAttributeInitializer() { AttributeDefinition<Properties> def = AttributeDefinition.builder("props", null, Properties.class).initializer(new AttributeInitializer<Properties>() { @Override public Properties initialize() { return new Properties(); } }).build(); Attribute<Properties> attribute1 = def.toAttribute(); Attribute<Properties> attribute2 = def.toAttribute(); assertTrue(attribute1.get() != attribute2.get()); } |
### Question:
StandardConversions { public static byte[] convertJavaToOctetStream(Object source, MediaType sourceMediaType, Marshaller marshaller) throws IOException, InterruptedException { if (source == null) return null; if (!sourceMediaType.match(MediaType.APPLICATION_OBJECT)) { throw new EncodingException("sourceMediaType not conforming to application/x-java-object!"); } Object decoded = decodeObjectContent(source, sourceMediaType); if (decoded instanceof byte[]) return (byte[]) decoded; if (decoded instanceof String && isJavaString(sourceMediaType)) return ((String) decoded).getBytes(StandardCharsets.UTF_8); return marshaller.objectToByteBuffer(source); } static Object convertTextToText(Object source, MediaType sourceType, MediaType destinationType); static byte[] convertTextToOctetStream(Object source, MediaType sourceType); static String convertTextToObject(Object source, MediaType sourceType); static String convertTextToUrlEncoded(Object source, MediaType sourceType); static byte[] convertOctetStreamToText(byte[] source, MediaType destination); static Object convertOctetStreamToJava(byte[] source, MediaType destination, Marshaller marshaller); static byte[] convertJavaToOctetStream(Object source, MediaType sourceMediaType, Marshaller marshaller); static byte[] convertJavaToProtoStream(Object source, MediaType sourceMediaType, ImmutableSerializationContext ctx); static byte[] convertJavaToText(Object source, MediaType sourceMediaType, MediaType destinationMediaType); static Object decodeObjectContent(Object content, MediaType contentMediaType); static byte[] convertCharset(Object content, Charset fromCharset, Charset toCharset); static byte[] decodeOctetStream(Object input, MediaType octetStream); static String bytesToHex(byte[] bytes); static byte[] hexToBytes(String hex); static Object convertUrlEncodedToObject(Object content); static Object convertUrlEncodedToText(Object content, MediaType destinationType); static Object convertUrlEncodedToOctetStream(Object content); static String urlEncode(Object content, MediaType mediaType); static Object urlDecode(Object content); static Object convertOctetStreamToUrlEncoded(Object content, MediaType contentType); }### Answer:
@Test public void testJavaToOctetStreamConversion() throws IOException, InterruptedException { Marshaller marshaller = new ProtoStreamMarshaller(); String string = "I've seen things you people wouldn't believe."; Double number = 12.1d; Instant complex = Instant.now(); byte[] binary = new byte[]{1, 2, 3}; MediaType stringType = APPLICATION_OBJECT.withParameter("type", "java.lang.String"); byte[] result = StandardConversions.convertJavaToOctetStream(string, stringType, marshaller); assertArrayEquals(string.getBytes(UTF_8), result); MediaType doubleType = APPLICATION_OBJECT.withParameter("type", "java.lang.Double"); result = StandardConversions.convertJavaToOctetStream(number, doubleType, marshaller); assertArrayEquals(marshaller.objectToByteBuffer(number), result); MediaType customType = APPLICATION_OBJECT.withParameter("type", complex.getClass().getName()); result = StandardConversions.convertJavaToOctetStream(complex, customType, marshaller); assertArrayEquals(marshaller.objectToByteBuffer(complex), result); MediaType byteArrayType = APPLICATION_OBJECT.withParameter("type", "ByteArray"); result = StandardConversions.convertJavaToOctetStream(binary, byteArrayType, marshaller); assertArrayEquals(result, binary); } |
### Question:
KeyTransformationHandler { public Object stringToKey(String s) { char type = s.charAt(0); switch (type) { case 'S': return s.substring(2); case 'I': return Integer.valueOf(s.substring(2)); case 'Y': return Byte.valueOf(s.substring(2)); case 'L': return Long.valueOf(s.substring(2)); case 'X': return Short.valueOf(s.substring(2)); case 'D': return Double.valueOf(s.substring(2)); case 'F': return Float.valueOf(s.substring(2)); case 'B': return Boolean.valueOf(s.substring(2)); case 'C': return Character.valueOf(s.charAt(2)); case 'U': return UUID.fromString(s.substring(2)); case 'A': return Base64.getDecoder().decode(s.substring(2)); case 'T': int indexOfSecondDelimiter = s.indexOf(':', 2); String keyClassName = s.substring(2, indexOfSecondDelimiter); String keyAsString = s.substring(indexOfSecondDelimiter + 1); Transformer t = getTransformer(keyClassName); if (t != null) { return t.fromString(keyAsString); } else { throw CONTAINER.noTransformerForKey(keyClassName); } } throw new CacheException("Unknown key type metadata: " + type); } KeyTransformationHandler(ClassLoader classLoader); Object stringToKey(String s); String keyToString(Object key); void registerTransformer(Class<?> keyClass, Class<? extends Transformer> transformerClass); }### Answer:
@Test(expectedExceptions = CacheException.class) public void testStringToUnknownKey() { keyTransformationHandler.stringToKey("Z:someKey"); }
@Test(expectedExceptions = CacheException.class) public void testStringToKeyWithInvalidTransformer() { keyTransformationHandler.stringToKey("T:org.infinispan.InexistentTransformer:key1"); } |
### Question:
KeyTransformationHandler { public String keyToString(Object key) { if (key instanceof byte[]) return "A:" + Base64.getEncoder().encodeToString((byte[]) key); if (key instanceof String) return "S:" + key; else if (key instanceof Integer) return "I:" + key; else if (key instanceof Boolean) return "B:" + key; else if (key instanceof Long) return "L:" + key; else if (key instanceof Float) return "F:" + key; else if (key instanceof Double) return "D:" + key; else if (key instanceof Short) return "X:" + key; else if (key instanceof Byte) return "Y:" + key; else if (key instanceof Character) return "C:" + key; else if (key instanceof UUID) return "U:" + key; else { Transformer t = getTransformer(key.getClass()); if (t != null) { return "T:" + key.getClass().getName() + ":" + t.toString(key); } else { throw CONTAINER.noTransformerForKey(key.getClass().getName()); } } } KeyTransformationHandler(ClassLoader classLoader); Object stringToKey(String s); String keyToString(Object key); void registerTransformer(Class<?> keyClass, Class<? extends Transformer> transformerClass); }### Answer:
@Test(expectedExceptions = IllegalArgumentException.class) public void testKeyToStringWithDefaultTransformerForNonSerializableObject() { NonSerializableKey key = new NonSerializableKey("test"); keyTransformationHandler.keyToString(key); } |
### Question:
HibernateSearchPropertyHelper extends ReflectionPropertyHelper { @Override public Object convertToPropertyType(Class<?> entityType, String[] propertyPath, String value) { IndexValueFieldDescriptor fieldDescriptor = getValueFieldDescriptor(entityType, propertyPath); if (fieldDescriptor == null) { return super.convertToPropertyType(entityType, propertyPath, value); } Class<?> type = fieldDescriptor.type().dslArgumentClass(); if (!(Date.class.equals(type))) { return super.convertToPropertyType(entityType, propertyPath, value); } try { return DateTools.stringToDate(value); } catch (ParseException e) { throw new ParsingException(e); } } HibernateSearchPropertyHelper(SearchMapping searchMapping, EntityNameResolver<Class<?>> entityNameResolver); @Override Object convertToPropertyType(Class<?> entityType, String[] propertyPath, String value); @Override Class<?> getPrimitivePropertyType(Class<?> entityType, String[] propertyPath); @Override boolean isRepeatedProperty(Class<?> entityType, String[] propertyPath); @Override boolean hasEmbeddedProperty(Class<?> entityType, String[] propertyPath); @Override boolean hasProperty(Class<?> entityType, String[] propertyPath); @Override IndexedFieldProvider<Class<?>> getIndexedFieldProvider(); static String KEY; static String VALUE; }### Answer:
@Test public void testConvertIdProperty() { assertThat(convertToPropertyType(TestEntity.class, "id", "42")).isEqualTo("42"); }
@Test public void testConvertStringProperty() { assertThat(convertToPropertyType(TestEntity.class, "name", "42")).isEqualTo("42"); }
@Test public void testConvertIntProperty() { assertThat(convertToPropertyType(TestEntity.class, "i", "42")).isEqualTo(42); }
@Test public void testConvertLongProperty() { assertThat(convertToPropertyType(TestEntity.class, "l", "42")).isEqualTo(42L); }
@Test public void testConvertFloatProperty() { assertThat(convertToPropertyType(TestEntity.class, "f", "42.0")).isEqualTo(42.0F); }
@Test public void testConvertDoubleProperty() { assertThat(convertToPropertyType(TestEntity.class, "d", "42.0")).isEqualTo(42.0D); } |
### Question:
EmptyIntSet extends AbstractImmutableIntSet { @Override public boolean containsAll(IntSet set) { return set.isEmpty(); } static IntSet getInstance(); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override boolean equals(Object obj); @Override String toString(); }### Answer:
@Test public void testContainsAll1() throws Exception { Set<Integer> hashSet = new HashSet<>(); hashSet.add(3); assertFalse(es.containsAll(hashSet)); assertTrue(hashSet.containsAll(es)); hashSet.remove(3); assertTrue(hashSet.containsAll(es)); assertTrue(es.containsAll(hashSet)); }
@Test public void testContainsAll() throws Exception { IntSet sis2 = new SingletonIntSet(3); assertFalse(es.containsAll(sis2)); assertTrue(sis2.containsAll(es)); IntSet sis3 = new RangeSet(0); assertTrue(sis3.containsAll(es)); assertTrue(es.containsAll(sis3)); } |
### Question:
HibernateSearchPropertyHelper extends ReflectionPropertyHelper { @Override public IndexedFieldProvider<Class<?>> getIndexedFieldProvider() { return entityType -> { IndexDescriptor indexDescriptor = getIndexDescriptor(entityType); if (indexDescriptor == null) { return IndexedFieldProvider.NO_INDEXING; } return new SearchFieldIndexingMetadata(indexDescriptor); }; } HibernateSearchPropertyHelper(SearchMapping searchMapping, EntityNameResolver<Class<?>> entityNameResolver); @Override Object convertToPropertyType(Class<?> entityType, String[] propertyPath, String value); @Override Class<?> getPrimitivePropertyType(Class<?> entityType, String[] propertyPath); @Override boolean isRepeatedProperty(Class<?> entityType, String[] propertyPath); @Override boolean hasEmbeddedProperty(Class<?> entityType, String[] propertyPath); @Override boolean hasProperty(Class<?> entityType, String[] propertyPath); @Override IndexedFieldProvider<Class<?>> getIndexedFieldProvider(); static String KEY; static String VALUE; }### Answer:
@Test public void testRecognizeAnalyzedField() { assertThat(propertyHelper.getIndexedFieldProvider().get(TestEntity.class).isAnalyzed(new String[]{"description"})).isTrue(); }
@Test public void testRecognizeStoredField() { assertThat(propertyHelper.getIndexedFieldProvider().get(TestEntity.class).isStored(new String[]{"description"})).isTrue(); }
@Test public void testRecognizeUnanalyzedField() { assertThat(propertyHelper.getIndexedFieldProvider().get(TestEntity.class).isAnalyzed(new String[]{"i"})).isFalse(); } |
### Question:
ReflectionHelper { public static PropertyAccessor getAccessor(Class<?> clazz, String propertyName) throws ReflectiveOperationException { if (propertyName == null || propertyName.length() == 0) { throw new IllegalArgumentException("Property name cannot be null or empty"); } if (propertyName.indexOf('.') != -1) { throw new IllegalArgumentException("The argument cannot be a nested property name"); } String propertyNameSuffix = Character.toUpperCase(propertyName.charAt(0)) + propertyName.substring(1); Class<?> c = clazz; while (c != null) { PropertyAccessor m = getAccessor(c, propertyName, propertyNameSuffix); if (m != null) { return m; } c = c.getSuperclass(); } throw new ReflectiveOperationException("Property not found: " + propertyName); } private ReflectionHelper(); static PropertyAccessor getAccessor(Class<?> clazz, String propertyName); }### Answer:
@Test public void testGetSimpleProperty() throws Exception { assertEquals(int.class, ReflectionHelper.getAccessor(Base.class, "prop1").getPropertyType()); assertEquals(float.class, ReflectionHelper.getAccessor(Base.class, "prop2").getPropertyType()); }
@Test public void testPropertyNotFound() throws Exception { expectedException.expect(ReflectiveOperationException.class); expectedException.expectMessage("Property not found: unknown"); ReflectionHelper.getAccessor(Base.class, "unknown"); }
@Test public void testGetNestedProperty() throws Exception { ReflectionHelper.PropertyAccessor prop3 = ReflectionHelper.getAccessor(Base.class, "prop3"); assertEquals(Base.class, prop3.getPropertyType()); assertEquals(int.class, prop3.getAccessor("prop1").getPropertyType()); }
@Test public void testGetMultipleProperty() throws Exception { assertEquals(Base.class, ReflectionHelper.getAccessor(A.class, "array").getPropertyType()); assertEquals(Float.class, ReflectionHelper.getAccessor(A.class, "array2").getPropertyType()); assertEquals(float.class, ReflectionHelper.getAccessor(A.class, "array3").getPropertyType()); assertEquals(Collection.class, ReflectionHelper.getAccessor(A.class, "array4").getPropertyType()); assertEquals(Integer.class, ReflectionHelper.getAccessor(A.class, "list").getPropertyType()); assertEquals(List.class, ReflectionHelper.getAccessor(A.class, "list2").getPropertyType()); assertEquals(Base.class, ReflectionHelper.getAccessor(A.class, "list3").getPropertyType()); assertEquals(Integer.class, ReflectionHelper.getAccessor(A.class, "map").getPropertyType()); assertEquals(Base.class, ReflectionHelper.getAccessor(A.class, "map2").getPropertyType()); assertEquals(Long.class, ReflectionHelper.getAccessor(A.class, "y").getPropertyType()); assertEquals(Long.class, ReflectionHelper.getAccessor(A.class, "z").getPropertyType()); assertEquals(Double.class, ReflectionHelper.getAccessor(A.class, "q").getPropertyType()); assertEquals(Double.class, ReflectionHelper.getAccessor(A.class, "w").getPropertyType()); } |
### Question:
Interval { public boolean contains(K value) { return (includeLower ? low.compareTo(value) <= 0 : low.compareTo(value) < 0) && (includeUpper ? up.compareTo(value) >= 0 : up.compareTo(value) > 0); } Interval(K low, boolean includeLower, K up, boolean includeUpper); static K getMinusInf(); static K getPlusInf(); boolean contains(K value); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final K low; final boolean includeLower; final K up; final boolean includeUpper; }### Answer:
@Test public void testContains() { assertTrue(new Interval(Interval.<Integer>getMinusInf(), false, 1000, false).contains(20)); assertFalse(new Interval(Interval.<Integer>getMinusInf(), false, 1000, false).contains(1000)); assertFalse(new Interval(Interval.<Integer>getMinusInf(), false, 1000, false).contains(1001)); assertTrue(new Interval(1000, false, Interval.<Integer>getPlusInf(), false).contains(2000)); assertFalse(new Interval(1000, false, Interval.<Integer>getPlusInf(), false).contains(1000)); assertFalse(new Interval(1000, false, Interval.<Integer>getPlusInf(), false).contains(999)); } |
### Question:
DoubleStat { Double getSum() { if (count == 0) { return null; } double tmp = sum + sumCompensation; if (Double.isNaN(tmp) && Double.isInfinite(simpleSum)) { return simpleSum; } else { return tmp; } } }### Answer:
@Test public void testEmptySum() { DoubleStat sum = new DoubleStat(); assertNull(sum.getSum()); } |
### Question:
DoubleStat { Double getAvg() { return count == 0 ? null : getSum() / count; } }### Answer:
@Test public void testEmptyAvg() { DoubleStat avg = new DoubleStat(); assertNull(avg.getAvg()); } |
### Question:
EmptyIntSet extends AbstractImmutableIntSet { @Override public IntStream intStream() { return IntStream.empty(); } static IntSet getInstance(); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override boolean equals(Object obj); @Override String toString(); }### Answer:
@Test public void testIntStream() throws Exception { assertEquals(0, es.intStream().count()); } |
### Question:
EmptyIntSet extends AbstractImmutableIntSet { @Override public boolean equals(Object obj) { if (obj instanceof Set) { return ((Set) obj).size() == 0; } return false; } static IntSet getInstance(); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override boolean equals(Object obj); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { IntSet sis2 = new SingletonIntSet(4); assertNotEquals(es, sis2); assertNotEquals(sis2, es); IntSet sis3 = new SmallIntSet(2); assertEquals(sis3, es); assertEquals(es, sis3); } |
### Question:
Configuration { public int maxRetries() { return maxRetries; } Configuration(ExecutorFactoryConfiguration asyncExecutorFactory, Supplier<FailoverRequestBalancingStrategy> balancingStrategyFactory, ClassLoader classLoader,
ClientIntelligence clientIntelligence, ConnectionPoolConfiguration connectionPool, int connectionTimeout, Class<? extends ConsistentHash>[] consistentHashImpl, boolean forceReturnValues, int keySizeEstimate,
Marshaller marshaller, Class<? extends Marshaller> marshallerClass,
ProtocolVersion protocolVersion, List<ServerConfiguration> servers, int socketTimeout, SecurityConfiguration security, boolean tcpNoDelay, boolean tcpKeepAlive,
int valueSizeEstimate, int maxRetries, NearCacheConfiguration nearCache,
List<ClusterConfiguration> clusters, List<String> serialAllowList, int batchSize,
TransactionConfiguration transaction, StatisticsConfiguration statistics, Features features,
List<SerializationContextInitializer> contextInitializers,
Map<String, RemoteCacheConfiguration> remoteCaches); ExecutorFactoryConfiguration asyncExecutorFactory(); Supplier<FailoverRequestBalancingStrategy> balancingStrategyFactory(); @Deprecated ClassLoader classLoader(); ClientIntelligence clientIntelligence(); ConnectionPoolConfiguration connectionPool(); int connectionTimeout(); Class<? extends ConsistentHash>[] consistentHashImpl(); Class<? extends ConsistentHash> consistentHashImpl(int version); boolean forceReturnValues(); @Deprecated int keySizeEstimate(); Marshaller marshaller(); Class<? extends Marshaller> marshallerClass(); @Deprecated NearCacheConfiguration nearCache(); ProtocolVersion version(); List<ServerConfiguration> servers(); List<ClusterConfiguration> clusters(); int socketTimeout(); SecurityConfiguration security(); boolean tcpNoDelay(); boolean tcpKeepAlive(); @Deprecated int valueSizeEstimate(); int maxRetries(); @Deprecated List<String> serialWhitelist(); List<String> serialAllowList(); @Deprecated ClassAllowList getClassWhiteList(); ClassAllowList getClassAllowList(); int batchSize(); Map<String, RemoteCacheConfiguration> remoteCaches(); RemoteCacheConfiguration addRemoteCache(String name, Consumer<RemoteCacheConfigurationBuilder> builderConsumer); void removeRemoteCache(String name); StatisticsConfiguration statistics(); TransactionConfiguration transaction(); Features features(); List<SerializationContextInitializer> getContextInitializers(); @Override String toString(); Properties properties(); }### Answer:
@Test(expectedExceptions = CacheConfigurationException.class, expectedExceptionsMessageRegExp = "ISPN(\\d)*: Invalid max_retries \\(value=-1\\). " + "Value should be greater or equal than zero.") public void testNegativeRetriesPerServer() { ConfigurationBuilder builder = HotRodClientTestingUtil.newRemoteConfigurationBuilder(); builder.maxRetries(-1); builder.build(); } |
### Question:
Configuration { public SecurityConfiguration security() { return security; } Configuration(ExecutorFactoryConfiguration asyncExecutorFactory, Supplier<FailoverRequestBalancingStrategy> balancingStrategyFactory, ClassLoader classLoader,
ClientIntelligence clientIntelligence, ConnectionPoolConfiguration connectionPool, int connectionTimeout, Class<? extends ConsistentHash>[] consistentHashImpl, boolean forceReturnValues, int keySizeEstimate,
Marshaller marshaller, Class<? extends Marshaller> marshallerClass,
ProtocolVersion protocolVersion, List<ServerConfiguration> servers, int socketTimeout, SecurityConfiguration security, boolean tcpNoDelay, boolean tcpKeepAlive,
int valueSizeEstimate, int maxRetries, NearCacheConfiguration nearCache,
List<ClusterConfiguration> clusters, List<String> serialAllowList, int batchSize,
TransactionConfiguration transaction, StatisticsConfiguration statistics, Features features,
List<SerializationContextInitializer> contextInitializers,
Map<String, RemoteCacheConfiguration> remoteCaches); ExecutorFactoryConfiguration asyncExecutorFactory(); Supplier<FailoverRequestBalancingStrategy> balancingStrategyFactory(); @Deprecated ClassLoader classLoader(); ClientIntelligence clientIntelligence(); ConnectionPoolConfiguration connectionPool(); int connectionTimeout(); Class<? extends ConsistentHash>[] consistentHashImpl(); Class<? extends ConsistentHash> consistentHashImpl(int version); boolean forceReturnValues(); @Deprecated int keySizeEstimate(); Marshaller marshaller(); Class<? extends Marshaller> marshallerClass(); @Deprecated NearCacheConfiguration nearCache(); ProtocolVersion version(); List<ServerConfiguration> servers(); List<ClusterConfiguration> clusters(); int socketTimeout(); SecurityConfiguration security(); boolean tcpNoDelay(); boolean tcpKeepAlive(); @Deprecated int valueSizeEstimate(); int maxRetries(); @Deprecated List<String> serialWhitelist(); List<String> serialAllowList(); @Deprecated ClassAllowList getClassWhiteList(); ClassAllowList getClassAllowList(); int batchSize(); Map<String, RemoteCacheConfiguration> remoteCaches(); RemoteCacheConfiguration addRemoteCache(String name, Consumer<RemoteCacheConfigurationBuilder> builderConsumer); void removeRemoteCache(String name); StatisticsConfiguration statistics(); TransactionConfiguration transaction(); Features features(); List<SerializationContextInitializer> getContextInitializers(); @Override String toString(); Properties properties(); }### Answer:
@Test(expectedExceptions = CacheConfigurationException.class) public void testInvalidAuthenticationConfig() { ConfigurationBuilder builder = HotRodClientTestingUtil.newRemoteConfigurationBuilder(); builder.security().authentication().enable().saslMechanism("PLAIN"); builder.build(); } |
### Question:
RocksDBStore implements NonBlockingStore<K, V> { @Override public CompletionStage<Void> write(int segment, MarshallableEntry<? extends K, ? extends V> entry) { return handler.write(segment, entry); } @Override CompletionStage<Void> start(InitializationContext ctx); @Override CompletionStage<Void> stop(); @Override Set<Characteristic> characteristics(); @Override CompletionStage<Boolean> isAvailable(); @Override CompletionStage<Void> clear(); @Override CompletionStage<Long> size(IntSet segments); @Override CompletionStage<Long> approximateSize(IntSet segments); @Override CompletionStage<Boolean> containsKey(int segment, Object key); @Override Publisher<K> publishKeys(IntSet segments, Predicate<? super K> filter); @Override Publisher<MarshallableEntry<K, V>> publishEntries(IntSet segments, Predicate<? super K> filter, boolean includeValues); @Override CompletionStage<Boolean> delete(int segment, Object key); @Override CompletionStage<Void> write(int segment, MarshallableEntry<? extends K, ? extends V> entry); @Override CompletionStage<MarshallableEntry<K, V>> load(int segment, Object key); @Override CompletionStage<Void> batch(int publisherCount, Publisher<SegmentedPublisher<Object>> removePublisher,
Publisher<SegmentedPublisher<MarshallableEntry<K, V>>> writePublisher); @Override Publisher<MarshallableEntry<K, V>> purgeExpired(); @Override CompletionStage<Void> addSegments(IntSet segments); @Override CompletionStage<Void> removeSegments(IntSet segments); }### Answer:
@Test(groups = "stress") public void testConcurrentWrite() throws InterruptedException { final int THREADS = 8; final AtomicBoolean run = new AtomicBoolean(true); final AtomicInteger written = new AtomicInteger(); final CountDownLatch started = new CountDownLatch(THREADS); final CountDownLatch finished = new CountDownLatch(THREADS); for (int i = 0; i < THREADS; ++i) { final int thread = i; fork(() -> { try { started.countDown(); int i1 = 0; while (run.get()) { InternalCacheEntry entry = TestInternalCacheEntryFactory.create("k" + i1, "v" + i1); MarshallableEntry me = MarshalledEntryUtil.create(entry, getMarshaller()); try { store.write(me); ++i1; int prev; do { prev = written.get(); if ((prev & (1 << thread)) != 0) break; } while (written.compareAndSet(prev, prev | (1 << thread))); } catch (PersistenceException e) { } } } catch (Exception e) { log.error("Failed", e); throw new RuntimeException(e); } finally { finished.countDown(); } }); } if (finished.await(1, TimeUnit.SECONDS)) { fail("Test shouldn't have finished yet"); } run.set(false); if (!finished.await(30, TimeUnit.SECONDS)) { fail("Test should have finished!"); } assertEquals(written.get(), (1 << THREADS) - 1, "pre"); } |
### Question:
L1ConfigurationBuilder extends AbstractClusteringConfigurationChildBuilder implements Builder<L1Configuration>, ConfigurationBuilderInfo { public L1ConfigurationBuilder enable() { attributes.attribute(ENABLED).set(true); return this; } L1ConfigurationBuilder(ClusteringConfigurationBuilder builder); @Override ElementDefinition getElementDefinition(); @Override AttributeSet attributes(); L1ConfigurationBuilder invalidationThreshold(int invalidationThreshold); L1ConfigurationBuilder lifespan(long lifespan); L1ConfigurationBuilder lifespan(long lifespan, TimeUnit unit); L1ConfigurationBuilder cleanupTaskFrequency(long frequencyMillis); L1ConfigurationBuilder cleanupTaskFrequency(long frequencyMillis, TimeUnit unit); L1ConfigurationBuilder enable(); L1ConfigurationBuilder disable(); L1ConfigurationBuilder enabled(boolean enabled); @Override void validate(); @Override void validate(GlobalConfiguration globalConfig); @Override L1Configuration create(); @Override L1ConfigurationBuilder read(L1Configuration template); @Override String toString(); }### Answer:
@Test(expectedExceptions = CacheConfigurationException.class) public void testL1WithExceptionEviction() { Configuration config = new ConfigurationBuilder() .clustering() .cacheMode(CacheMode.DIST_SYNC) .l1().enable() .memory() .evictionStrategy(EvictionStrategy.EXCEPTION) .size(10) .transaction() .transactionMode(org.infinispan.transaction.TransactionMode.TRANSACTIONAL) .build(); assertNotNull(config); } |
### Question:
DependencyGraph { public List<T> topologicalSort() throws CyclicDependencyException { lock.readLock().lock(); try { ArrayList<T> result = new ArrayList<>(); Deque<T> noIncomingEdges = new ArrayDeque<>(); Map<T, Integer> temp = new HashMap<>(); for (Map.Entry<T, Set<T>> incoming : incomingEdges.entrySet()) { int size = incoming.getValue().size(); T key = incoming.getKey(); temp.put(key, size); if (size == 0) { noIncomingEdges.add(key); } } while (!noIncomingEdges.isEmpty()) { T n = noIncomingEdges.poll(); result.add(n); temp.remove(n); Set<T> elements = outgoingEdges.get(n); if (elements != null) { for (T m : elements) { Integer count = temp.get(m); temp.put(m, --count); if (count == 0) { noIncomingEdges.add(m); } } } } if (!temp.isEmpty()) { throw new CyclicDependencyException("Cycle detected"); } else { return result; } } finally { lock.readLock().unlock(); } } List<T> topologicalSort(); void addDependency(T from, T to); void removeDependency(T from, T to); void clearAll(); boolean hasDependent(T element); Set<T> getDependents(T element); void remove(T element); }### Answer:
@Test public void testEmpty() throws CyclicDependencyException { assertTrue(new DependencyGraph().topologicalSort().isEmpty()); }
@Test public void testConcurrentAccess() throws Exception { DependencyGraph<String> graph = new DependencyGraph<>(); ExecutorService service = Executors.newCachedThreadPool(getTestThreadFactory("Worker")); try { CountDownLatch startLatch = new CountDownLatch(1); int threads = 20; ArrayList<Future<?>> futures = new ArrayList<>(); for (int i = 0; i < threads; i++) { futures.add(submitTask("A", "B", startLatch, service, graph)); futures.add(submitTask("A", "C", startLatch, service, graph)); futures.add(submitTask("A", "D", startLatch, service, graph)); futures.add(submitTask("A", "B", startLatch, service, graph)); futures.add(submitTask("D", "B", startLatch, service, graph)); futures.add(submitTask("D", "C", startLatch, service, graph)); futures.add(submitTask("C", "B", startLatch, service, graph)); } startLatch.countDown(); awaitAll(futures); } finally { service.shutdownNow(); } assertEquals(graph.topologicalSort(), Arrays.asList("A", "D", "C", "B")); } |
### Question:
DependencyGraph { public void removeDependency(T from, T to) { lock.writeLock().lock(); try { Set<T> dependencies = outgoingEdges.get(from); if (dependencies == null || !dependencies.contains(to)) { throw new IllegalArgumentException("Inexistent dependency"); } dependencies.remove(to); incomingEdges.get(to).remove(from); } finally { lock.writeLock().unlock(); } } List<T> topologicalSort(); void addDependency(T from, T to); void removeDependency(T from, T to); void clearAll(); boolean hasDependent(T element); Set<T> getDependents(T element); void remove(T element); }### Answer:
@Test public void testRemoveDependency() throws CyclicDependencyException { DependencyGraph<String> g = new DependencyGraph<>(); g.addDependency("E", "B"); g.addDependency("E", "C"); g.addDependency("E", "D"); g.addDependency("B", "D"); g.addDependency("B", "C"); g.addDependency("C", "D"); assertEquals(g.topologicalSort(), Arrays.asList("E", "B", "C", "D")); g.removeDependency("E", "B"); g.addDependency("B", "E"); assertEquals(g.topologicalSort(), Arrays.asList("B", "E", "C", "D")); g.clearAll(); assertTrue(g.topologicalSort().isEmpty()); } |
### Question:
DependencyGraph { public void addDependency(T from, T to) { if (from == null || to == null || from.equals(to)) { throw new IllegalArgumentException("Invalid parameters"); } lock.writeLock().lock(); try { if (addOutgoingEdge(from, to)) { addIncomingEdge(to, from); } } finally { lock.writeLock().unlock(); } } List<T> topologicalSort(); void addDependency(T from, T to); void removeDependency(T from, T to); void clearAll(); boolean hasDependent(T element); Set<T> getDependents(T element); void remove(T element); }### Answer:
@Test(expectedExceptions = IllegalArgumentException.class) public void testAddSelf() { new DependencyGraph<>().addDependency("N", "N"); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testAdNull() { new DependencyGraph<>().addDependency("N", null); } |
### Question:
GridFile extends File { @Override public boolean createNewFile() throws IOException { if (exists()) return false; if (!checkParentDirs(getAbsolutePath(), false)) throw new IOException("Cannot create file " + getAbsolutePath() + " (parent dir does not exist)"); metadataCache.put(getAbsolutePath(), new Metadata(0, System.currentTimeMillis(), chunkSize, Metadata.FILE)); return true; } GridFile(String pathname, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(String parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(File parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); @Override String getName(); @Override String getPath(); @Override String getAbsolutePath(); @Override File getAbsoluteFile(); @Override String getCanonicalPath(); @Override File getCanonicalFile(); @Override boolean isAbsolute(); @Override boolean renameTo(File dest); @Override void deleteOnExit(); @Override long length(); int getChunkSize(); @Override boolean createNewFile(); @Override boolean delete(); @Override boolean mkdir(); @Override boolean mkdirs(); @Override boolean exists(); @Override String getParent(); @Override File getParentFile(); @Override long lastModified(); @Override boolean setLastModified(long time); @Override String[] list(); @Override String[] list(FilenameFilter filter); @Override File[] listFiles(); @Override File[] listFiles(FilenameFilter filter); @Override File[] listFiles(FileFilter filter); @Override boolean isDirectory(); @Override boolean isFile(); @Override boolean equals(Object obj); @Override boolean canRead(); @Override boolean canWrite(); @Override boolean isHidden(); @Override boolean canExecute(); @Override int compareTo(File file); @Override int hashCode(); @Override String toString(); @Override URL toURL(); @Override URI toURI(); @Override boolean setReadOnly(); @Override boolean setWritable(boolean writable, boolean ownerOnly); @Override boolean setWritable(boolean writable); @Override boolean setReadable(boolean readable, boolean ownerOnly); @Override boolean setReadable(boolean readable); @Override boolean setExecutable(boolean executable, boolean ownerOnly); @Override boolean setExecutable(boolean executable); @Override long getTotalSpace(); @Override long getFreeSpace(); @Override long getUsableSpace(); }### Answer:
@Test(expectedExceptions = IOException.class) public void testCreateNewFileInNonExistentDir() throws IOException { File file = fs.getFile("nonExistent/file.txt"); file.createNewFile(); } |
### Question:
EmptyIntSet extends AbstractImmutableIntSet { @Override public int size() { return 0; } static IntSet getInstance(); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override boolean equals(Object obj); @Override String toString(); }### Answer:
@Test public void testForEachPrimitive() { Set<Integer> results = new HashSet<>(); es.forEach((IntConsumer) results::add); assertEquals(0, results.size()); }
@Test public void testForEachObject() { Set<Integer> results = new HashSet<>(); es.forEach((Consumer<? super Integer>) results::add); assertEquals(0, results.size()); }
@Test public void testIntSpliteratorForEachRemaining() { Set<Integer> results = new HashSet<>(); es.intSpliterator().forEachRemaining((IntConsumer) results::add); assertEquals(0, results.size()); }
@Test public void testIntSpliteratorSplitTryAdvance() { Set<Integer> results = new HashSet<>(); Spliterator.OfInt spliterator = es.intSpliterator(); Spliterator.OfInt split = spliterator.trySplit(); assertNull(split); IntConsumer consumer = results::add; while (spliterator.tryAdvance(consumer)) { } assertEquals(0, results.size()); }
@Test public void testSize() { assertEquals(0, es.size()); } |
### Question:
GridFile extends File { @Override public String getPath() { return path; } GridFile(String pathname, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(String parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(File parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); @Override String getName(); @Override String getPath(); @Override String getAbsolutePath(); @Override File getAbsoluteFile(); @Override String getCanonicalPath(); @Override File getCanonicalFile(); @Override boolean isAbsolute(); @Override boolean renameTo(File dest); @Override void deleteOnExit(); @Override long length(); int getChunkSize(); @Override boolean createNewFile(); @Override boolean delete(); @Override boolean mkdir(); @Override boolean mkdirs(); @Override boolean exists(); @Override String getParent(); @Override File getParentFile(); @Override long lastModified(); @Override boolean setLastModified(long time); @Override String[] list(); @Override String[] list(FilenameFilter filter); @Override File[] listFiles(); @Override File[] listFiles(FilenameFilter filter); @Override File[] listFiles(FileFilter filter); @Override boolean isDirectory(); @Override boolean isFile(); @Override boolean equals(Object obj); @Override boolean canRead(); @Override boolean canWrite(); @Override boolean isHidden(); @Override boolean canExecute(); @Override int compareTo(File file); @Override int hashCode(); @Override String toString(); @Override URL toURL(); @Override URI toURI(); @Override boolean setReadOnly(); @Override boolean setWritable(boolean writable, boolean ownerOnly); @Override boolean setWritable(boolean writable); @Override boolean setReadable(boolean readable, boolean ownerOnly); @Override boolean setReadable(boolean readable); @Override boolean setExecutable(boolean executable, boolean ownerOnly); @Override boolean setExecutable(boolean executable); @Override long getTotalSpace(); @Override long getFreeSpace(); @Override long getUsableSpace(); }### Answer:
@Test(expectedExceptions = FileNotFoundException.class) public void testWritingToDirectoryThrowsException2() throws IOException { File dir = createDir(); fs.getOutput(dir.getPath()); }
@Test(expectedExceptions = FileNotFoundException.class) public void testReadingFromDirectoryThrowsException2() throws IOException { File dir = createDir(); fs.getInput(dir.getPath()); } |
### Question:
GridFile extends File { @Override public void deleteOnExit() { throw new UnsupportedOperationException("Not implemented"); } GridFile(String pathname, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(String parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(File parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); @Override String getName(); @Override String getPath(); @Override String getAbsolutePath(); @Override File getAbsoluteFile(); @Override String getCanonicalPath(); @Override File getCanonicalFile(); @Override boolean isAbsolute(); @Override boolean renameTo(File dest); @Override void deleteOnExit(); @Override long length(); int getChunkSize(); @Override boolean createNewFile(); @Override boolean delete(); @Override boolean mkdir(); @Override boolean mkdirs(); @Override boolean exists(); @Override String getParent(); @Override File getParentFile(); @Override long lastModified(); @Override boolean setLastModified(long time); @Override String[] list(); @Override String[] list(FilenameFilter filter); @Override File[] listFiles(); @Override File[] listFiles(FilenameFilter filter); @Override File[] listFiles(FileFilter filter); @Override boolean isDirectory(); @Override boolean isFile(); @Override boolean equals(Object obj); @Override boolean canRead(); @Override boolean canWrite(); @Override boolean isHidden(); @Override boolean canExecute(); @Override int compareTo(File file); @Override int hashCode(); @Override String toString(); @Override URL toURL(); @Override URI toURI(); @Override boolean setReadOnly(); @Override boolean setWritable(boolean writable, boolean ownerOnly); @Override boolean setWritable(boolean writable); @Override boolean setReadable(boolean readable, boolean ownerOnly); @Override boolean setReadable(boolean readable); @Override boolean setExecutable(boolean executable, boolean ownerOnly); @Override boolean setExecutable(boolean executable); @Override long getTotalSpace(); @Override long getFreeSpace(); @Override long getUsableSpace(); }### Answer:
@Test(expectedExceptions = UnsupportedOperationException.class) public void testDeleteOnExit() { fs.getFile("nonsuch.txt").deleteOnExit(); } |
### Question:
GridFile extends File { @Override public boolean renameTo(File dest) { throw new UnsupportedOperationException("Not implemented"); } GridFile(String pathname, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(String parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(File parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); @Override String getName(); @Override String getPath(); @Override String getAbsolutePath(); @Override File getAbsoluteFile(); @Override String getCanonicalPath(); @Override File getCanonicalFile(); @Override boolean isAbsolute(); @Override boolean renameTo(File dest); @Override void deleteOnExit(); @Override long length(); int getChunkSize(); @Override boolean createNewFile(); @Override boolean delete(); @Override boolean mkdir(); @Override boolean mkdirs(); @Override boolean exists(); @Override String getParent(); @Override File getParentFile(); @Override long lastModified(); @Override boolean setLastModified(long time); @Override String[] list(); @Override String[] list(FilenameFilter filter); @Override File[] listFiles(); @Override File[] listFiles(FilenameFilter filter); @Override File[] listFiles(FileFilter filter); @Override boolean isDirectory(); @Override boolean isFile(); @Override boolean equals(Object obj); @Override boolean canRead(); @Override boolean canWrite(); @Override boolean isHidden(); @Override boolean canExecute(); @Override int compareTo(File file); @Override int hashCode(); @Override String toString(); @Override URL toURL(); @Override URI toURI(); @Override boolean setReadOnly(); @Override boolean setWritable(boolean writable, boolean ownerOnly); @Override boolean setWritable(boolean writable); @Override boolean setReadable(boolean readable, boolean ownerOnly); @Override boolean setReadable(boolean readable); @Override boolean setExecutable(boolean executable, boolean ownerOnly); @Override boolean setExecutable(boolean executable); @Override long getTotalSpace(); @Override long getFreeSpace(); @Override long getUsableSpace(); }### Answer:
@Test(expectedExceptions = UnsupportedOperationException.class) public void testRenameTo(){ fs.getFile("file.txt").renameTo(null); } |
### Question:
GridFile extends File { @Override public String getCanonicalPath() throws IOException { throw new UnsupportedOperationException("Not implemented"); } GridFile(String pathname, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(String parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(File parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); @Override String getName(); @Override String getPath(); @Override String getAbsolutePath(); @Override File getAbsoluteFile(); @Override String getCanonicalPath(); @Override File getCanonicalFile(); @Override boolean isAbsolute(); @Override boolean renameTo(File dest); @Override void deleteOnExit(); @Override long length(); int getChunkSize(); @Override boolean createNewFile(); @Override boolean delete(); @Override boolean mkdir(); @Override boolean mkdirs(); @Override boolean exists(); @Override String getParent(); @Override File getParentFile(); @Override long lastModified(); @Override boolean setLastModified(long time); @Override String[] list(); @Override String[] list(FilenameFilter filter); @Override File[] listFiles(); @Override File[] listFiles(FilenameFilter filter); @Override File[] listFiles(FileFilter filter); @Override boolean isDirectory(); @Override boolean isFile(); @Override boolean equals(Object obj); @Override boolean canRead(); @Override boolean canWrite(); @Override boolean isHidden(); @Override boolean canExecute(); @Override int compareTo(File file); @Override int hashCode(); @Override String toString(); @Override URL toURL(); @Override URI toURI(); @Override boolean setReadOnly(); @Override boolean setWritable(boolean writable, boolean ownerOnly); @Override boolean setWritable(boolean writable); @Override boolean setReadable(boolean readable, boolean ownerOnly); @Override boolean setReadable(boolean readable); @Override boolean setExecutable(boolean executable, boolean ownerOnly); @Override boolean setExecutable(boolean executable); @Override long getTotalSpace(); @Override long getFreeSpace(); @Override long getUsableSpace(); }### Answer:
@Test(expectedExceptions = UnsupportedOperationException.class) public void testGetCanonicalPath() throws IOException { fs.getFile("nonsuch.txt").getCanonicalPath(); } |
### Question:
GridFile extends File { @Override public File getCanonicalFile() throws IOException { throw new UnsupportedOperationException("Not implemented"); } GridFile(String pathname, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(String parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(File parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); @Override String getName(); @Override String getPath(); @Override String getAbsolutePath(); @Override File getAbsoluteFile(); @Override String getCanonicalPath(); @Override File getCanonicalFile(); @Override boolean isAbsolute(); @Override boolean renameTo(File dest); @Override void deleteOnExit(); @Override long length(); int getChunkSize(); @Override boolean createNewFile(); @Override boolean delete(); @Override boolean mkdir(); @Override boolean mkdirs(); @Override boolean exists(); @Override String getParent(); @Override File getParentFile(); @Override long lastModified(); @Override boolean setLastModified(long time); @Override String[] list(); @Override String[] list(FilenameFilter filter); @Override File[] listFiles(); @Override File[] listFiles(FilenameFilter filter); @Override File[] listFiles(FileFilter filter); @Override boolean isDirectory(); @Override boolean isFile(); @Override boolean equals(Object obj); @Override boolean canRead(); @Override boolean canWrite(); @Override boolean isHidden(); @Override boolean canExecute(); @Override int compareTo(File file); @Override int hashCode(); @Override String toString(); @Override URL toURL(); @Override URI toURI(); @Override boolean setReadOnly(); @Override boolean setWritable(boolean writable, boolean ownerOnly); @Override boolean setWritable(boolean writable); @Override boolean setReadable(boolean readable, boolean ownerOnly); @Override boolean setReadable(boolean readable); @Override boolean setExecutable(boolean executable, boolean ownerOnly); @Override boolean setExecutable(boolean executable); @Override long getTotalSpace(); @Override long getFreeSpace(); @Override long getUsableSpace(); }### Answer:
@Test(expectedExceptions = UnsupportedOperationException.class) public void testGetCanonicalFile() throws IOException { fs.getFile("nonsuch.txt").getCanonicalFile(); } |
### Question:
GridFile extends File { @Override public URL toURL() throws MalformedURLException { throw new UnsupportedOperationException("Not implemented"); } GridFile(String pathname, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(String parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(File parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); @Override String getName(); @Override String getPath(); @Override String getAbsolutePath(); @Override File getAbsoluteFile(); @Override String getCanonicalPath(); @Override File getCanonicalFile(); @Override boolean isAbsolute(); @Override boolean renameTo(File dest); @Override void deleteOnExit(); @Override long length(); int getChunkSize(); @Override boolean createNewFile(); @Override boolean delete(); @Override boolean mkdir(); @Override boolean mkdirs(); @Override boolean exists(); @Override String getParent(); @Override File getParentFile(); @Override long lastModified(); @Override boolean setLastModified(long time); @Override String[] list(); @Override String[] list(FilenameFilter filter); @Override File[] listFiles(); @Override File[] listFiles(FilenameFilter filter); @Override File[] listFiles(FileFilter filter); @Override boolean isDirectory(); @Override boolean isFile(); @Override boolean equals(Object obj); @Override boolean canRead(); @Override boolean canWrite(); @Override boolean isHidden(); @Override boolean canExecute(); @Override int compareTo(File file); @Override int hashCode(); @Override String toString(); @Override URL toURL(); @Override URI toURI(); @Override boolean setReadOnly(); @Override boolean setWritable(boolean writable, boolean ownerOnly); @Override boolean setWritable(boolean writable); @Override boolean setReadable(boolean readable, boolean ownerOnly); @Override boolean setReadable(boolean readable); @Override boolean setExecutable(boolean executable, boolean ownerOnly); @Override boolean setExecutable(boolean executable); @Override long getTotalSpace(); @Override long getFreeSpace(); @Override long getUsableSpace(); }### Answer:
@Test(expectedExceptions = UnsupportedOperationException.class) public void testToURL() throws MalformedURLException { fs.getFile("nonsuch.txt").toURL(); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.