Datasets:

Minata

/

512src_fm_fc_ms_ff_method2testcases_v0

like 0

### Question: FormattedSqlChangeLogParser implements ChangeLogParser { public boolean supports(String changeLogFile, ResourceAccessor resourceAccessor) { BufferedReader reader = null; try { if (changeLogFile.endsWith(".sql")) { reader = new BufferedReader(new InputStreamReader(openChangeLogFile(changeLogFile, resourceAccessor))); return reader.readLine().matches("\\-\\-\\s*liquibase formatted.*"); } else { return false; } } catch (IOException e) { LogFactory.getLogger().debug("Exception reading " + changeLogFile, e); return false; } finally { if (reader != null) { try { reader.close(); } catch (IOException e) { LogFactory.getLogger().debug("Exception closing " + changeLogFile, e); } } } } boolean supports(String changeLogFile, ResourceAccessor resourceAccessor); int getPriority(); DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor); }### Answer: @Test public void supports() throws Exception { assertTrue(new MockFormattedSqlChangeLogParser(VALID_CHANGELOG).supports("asdf.sql", new JUnitResourceAccessor())); assertFalse(new MockFormattedSqlChangeLogParser(INVALID_CHANGELOG).supports("asdf.sql", new JUnitResourceAccessor())); }

### Question: ChangeLogParserFactory { public static ChangeLogParserFactory getInstance() { if (instance == null) { instance = new ChangeLogParserFactory(); } return instance; } private ChangeLogParserFactory(); static void reset(); static ChangeLogParserFactory getInstance(); List<ChangeLogParser> getParsers(); ChangeLogParser getParser(String fileNameOrExtension, ResourceAccessor resourceAccessor); void register(ChangeLogParser changeLogParser); void unregister(ChangeLogParser changeLogParser); }### Answer: @Test public void getInstance() { assertNotNull(ChangeLogParserFactory.getInstance()); assertTrue(ChangeLogParserFactory.getInstance() == ChangeLogParserFactory.getInstance()); }

### Question: ChangeLogParserFactory { public void register(ChangeLogParser changeLogParser) { parsers.add(changeLogParser); Collections.sort(parsers, changelogParserComparator); } private ChangeLogParserFactory(); static void reset(); static ChangeLogParserFactory getInstance(); List<ChangeLogParser> getParsers(); ChangeLogParser getParser(String fileNameOrExtension, ResourceAccessor resourceAccessor); void register(ChangeLogParser changeLogParser); void unregister(ChangeLogParser changeLogParser); }### Answer: @Test public void register() { ChangeLogParserFactory.getInstance().getParsers().clear(); assertEquals(0, ChangeLogParserFactory.getInstance().getParsers().size()); ChangeLogParserFactory.getInstance().register(new MockChangeLogParser("mock")); assertEquals(1, ChangeLogParserFactory.getInstance().getParsers().size()); }

### Question: CacheDatabase extends AbstractDatabase { @Override public boolean supportsSequences() { return false; } String getCurrentDateTimeFunction(); String getDefaultDriver(String url); int getPriority(); String getTypeName(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsInitiallyDeferrableColumns(); @Override String getLineComment(); @Override boolean supportsSequences(); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override String getViewDefinition(String schemaName, String viewName); static final String PRODUCT_NAME; }### Answer: @Test public void supportsSequences() { assertFalse(database.supportsSequences()); }

### Question: ChangeLogParserFactory { public static void reset() { instance = new ChangeLogParserFactory(); } private ChangeLogParserFactory(); static void reset(); static ChangeLogParserFactory getInstance(); List<ChangeLogParser> getParsers(); ChangeLogParser getParser(String fileNameOrExtension, ResourceAccessor resourceAccessor); void register(ChangeLogParser changeLogParser); void unregister(ChangeLogParser changeLogParser); }### Answer: @Test public void reset() { ChangeLogParserFactory instance1 = ChangeLogParserFactory.getInstance(); ChangeLogParserFactory.reset(); assertFalse(instance1 == ChangeLogParserFactory.getInstance()); }

### Question: ChangeLogParserFactory { public List<ChangeLogParser> getParsers() { return parsers; } private ChangeLogParserFactory(); static void reset(); static ChangeLogParserFactory getInstance(); List<ChangeLogParser> getParsers(); ChangeLogParser getParser(String fileNameOrExtension, ResourceAccessor resourceAccessor); void register(ChangeLogParser changeLogParser); void unregister(ChangeLogParser changeLogParser); }### Answer: @Test public void getParsers() throws Exception { ChangeLogParser parser = ChangeLogParserFactory.getInstance().getParser("asdf.xml", new JUnitResourceAccessor()); assertNotNull(parser); assertTrue(parser instanceof XMLChangeLogSAXParser); }

### Question: ServiceLocator { public static void reset() { instance = new ServiceLocator(); } protected ServiceLocator(); protected ServiceLocator(ResourceAccessor accessor); protected ServiceLocator(PackageScanClassResolver classResolver); protected ServiceLocator(PackageScanClassResolver classResolver, ResourceAccessor accessor); static ServiceLocator getInstance(); static void setInstance(ServiceLocator newInstance); void setResourceAccessor(ResourceAccessor resourceAccessor); void addPackageToScan(String packageName); Class findClass(Class requiredInterface); Class[] findClasses(Class requiredInterface); Object newInstance(Class requiredInterface); static void reset(); }### Answer: @Test public void reset() { ServiceLocator instance1 = ServiceLocator.getInstance(); ServiceLocator.reset(); assertFalse(instance1 == ServiceLocator.getInstance()); }

### Question: ServiceLocator { public Class[] findClasses(Class requiredInterface) throws ServiceNotFoundException { logger.debug("ServiceLocator.findClasses for "+requiredInterface.getName()); try { Class.forName(requiredInterface.getName()); if (!classesBySuperclass.containsKey(requiredInterface)) { classesBySuperclass.put(requiredInterface, findClassesImpl(requiredInterface)); } } catch (Exception e) { throw new ServiceNotFoundException(e); } List<Class> classes = classesBySuperclass.get(requiredInterface); HashSet<Class> uniqueClasses = new HashSet<Class>(classes); return uniqueClasses.toArray(new Class[uniqueClasses.size()]); } protected ServiceLocator(); protected ServiceLocator(ResourceAccessor accessor); protected ServiceLocator(PackageScanClassResolver classResolver); protected ServiceLocator(PackageScanClassResolver classResolver, ResourceAccessor accessor); static ServiceLocator getInstance(); static void setInstance(ServiceLocator newInstance); void setResourceAccessor(ResourceAccessor resourceAccessor); void addPackageToScan(String packageName); Class findClass(Class requiredInterface); Class[] findClasses(Class requiredInterface); Object newInstance(Class requiredInterface); static void reset(); }### Answer: @Test public void getClasses() throws Exception { Class[] classes = serviceLocator.findClasses(ChangeLogParser.class); assertTrue(classes.length > 0); }

### Question: ServiceLocator { public Class findClass(Class requiredInterface) throws ServiceNotFoundException { if (requiredInterface == Logger.class ) { return DefaultLogger.class; } else if ( requiredInterface == Executor.class ) { return JdbcExecutor.class; } else { throw new ServiceNotFoundException("Could not find implementation of " + requiredInterface.getName()); } } protected ServiceLocator(); protected ServiceLocator(ResourceAccessor accessor); protected ServiceLocator(PackageScanClassResolver classResolver); protected ServiceLocator(PackageScanClassResolver classResolver, ResourceAccessor accessor); static ServiceLocator getInstance(); static void setInstance(ServiceLocator newInstance); void setResourceAccessor(ResourceAccessor resourceAccessor); void addPackageToScan(String packageName); Class findClass(Class requiredInterface); Class[] findClasses(Class requiredInterface); Object newInstance(Class requiredInterface); static void reset(); }### Answer: @Test public void findClass() throws Exception { Class[] classes = serviceLocator.findClasses(Database.class); for (Class clazz : classes) { assertFalse(clazz.getName()+" is abstract", Modifier.isAbstract(clazz.getModifiers())); assertFalse(clazz.getName()+" is an interface", Modifier.isInterface(clazz.getModifiers())); assertNotNull(clazz.getConstructors()); } assertTrue(classes.length > 0); }

### Question: LockService { public static LockService getInstance(Database database) { if (!instances.containsKey(database)) { instances.put(database, new LockService(database)); } return instances.get(database); } private LockService(Database database); static LockService getInstance(Database database); void setChangeLogLockWaitTime(long changeLogLockWaitTime); void setChangeLogLockRecheckTime(long changeLogLocRecheckTime); boolean hasChangeLogLock(); void waitForLock(); boolean acquireLock(); void releaseLock(); DatabaseChangeLogLock[] listLocks(); void forceReleaseLock(); void reset(); static void resetAll(); }### Answer: @Test public void getInstance() { final Database oracle1 = new OracleDatabase() { @Override public boolean equals(Object o) { return o == this; } }; final Database oracle2 = new OracleDatabase() { @Override public boolean equals(Object o) { return o == this; } }; final Database mysql = new MySQLDatabase() { @Override public boolean equals(Object o) { return o == this; } }; assertNotNull(LockService.getInstance(oracle1)); assertNotNull(LockService.getInstance(oracle2)); assertNotNull(LockService.getInstance(mysql)); assertTrue(LockService.getInstance(oracle1) == LockService.getInstance(oracle1)); assertTrue(LockService.getInstance(oracle2) == LockService.getInstance(oracle2)); assertTrue(LockService.getInstance(mysql) == LockService.getInstance(mysql)); assertTrue(LockService.getInstance(oracle1) != LockService.getInstance(oracle2)); assertTrue(LockService.getInstance(oracle1) != LockService.getInstance(mysql)); }

### Question: CacheDatabase extends AbstractDatabase { @Override public String getLineComment() { return "--"; } String getCurrentDateTimeFunction(); String getDefaultDriver(String url); int getPriority(); String getTypeName(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsInitiallyDeferrableColumns(); @Override String getLineComment(); @Override boolean supportsSequences(); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override String getViewDefinition(String schemaName, String viewName); static final String PRODUCT_NAME; }### Answer: @Test public void getLineComment() { Assert.assertEquals("--", database.getLineComment()); }

### Question: CacheDatabase extends AbstractDatabase { public String getDefaultDriver(String url) { if (url.startsWith("jdbc:Cache")) { return "com.intersys.jdbc.CacheDriver"; } return null; } String getCurrentDateTimeFunction(); String getDefaultDriver(String url); int getPriority(); String getTypeName(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsInitiallyDeferrableColumns(); @Override String getLineComment(); @Override boolean supportsSequences(); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override String getViewDefinition(String schemaName, String viewName); static final String PRODUCT_NAME; }### Answer: @Test public void getDefaultDriver() { Assert.assertEquals("com.intersys.jdbc.CacheDriver", database.getDefaultDriver("jdbc:Cache: }

### Question: CacheDatabase extends AbstractDatabase { public String getTypeName() { return "cache"; } String getCurrentDateTimeFunction(); String getDefaultDriver(String url); int getPriority(); String getTypeName(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsInitiallyDeferrableColumns(); @Override String getLineComment(); @Override boolean supportsSequences(); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override String getViewDefinition(String schemaName, String viewName); static final String PRODUCT_NAME; }### Answer: @Test public void getTypeName() { Assert.assertEquals("cache", database.getTypeName()); }

### Question: CacheDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "SYSDATE"; } String getCurrentDateTimeFunction(); String getDefaultDriver(String url); int getPriority(); String getTypeName(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsInitiallyDeferrableColumns(); @Override String getLineComment(); @Override boolean supportsSequences(); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override String getViewDefinition(String schemaName, String viewName); static final String PRODUCT_NAME; }### Answer: @Override @Test public void getCurrentDateTimeFunction() { Assert.assertEquals("SYSDATE", database.getCurrentDateTimeFunction()); }

### Question: CacheDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return false; } String getCurrentDateTimeFunction(); String getDefaultDriver(String url); int getPriority(); String getTypeName(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsInitiallyDeferrableColumns(); @Override String getLineComment(); @Override boolean supportsSequences(); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override String getViewDefinition(String schemaName, String viewName); static final String PRODUCT_NAME; }### Answer: @Override @Test public void supportsInitiallyDeferrableColumns() { assertFalse(database.supportsInitiallyDeferrableColumns()); }

### Question: PostgresDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return true; } PostgresDatabase(); @Override void setConnection(DatabaseConnection conn); String getTypeName(); @Override Set<String> getSystemTablesAndViews(); int getPriority(); boolean supportsInitiallyDeferrableColumns(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); @Override boolean supportsSequences(); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getDatabaseChangeLogTableName(); @Override String getDatabaseChangeLogLockTableName(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); boolean supportsTablespaces(); @Override String getAutoIncrementClause(); @Override boolean generateAutoIncrementStartWith(BigInteger startWith); @Override boolean generateAutoIncrementBy(BigInteger incrementBy); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String tableName); @Override String escapeIndexName(String schemaName, String indexName); static final String PRODUCT_NAME; }### Answer: @Override @Test public void supportsInitiallyDeferrableColumns() { assertTrue(getDatabase().supportsInitiallyDeferrableColumns()); }

### Question: PostgresDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "NOW()"; } PostgresDatabase(); @Override void setConnection(DatabaseConnection conn); String getTypeName(); @Override Set<String> getSystemTablesAndViews(); int getPriority(); boolean supportsInitiallyDeferrableColumns(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); @Override boolean supportsSequences(); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getDatabaseChangeLogTableName(); @Override String getDatabaseChangeLogLockTableName(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); boolean supportsTablespaces(); @Override String getAutoIncrementClause(); @Override boolean generateAutoIncrementStartWith(BigInteger startWith); @Override boolean generateAutoIncrementBy(BigInteger incrementBy); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String tableName); @Override String escapeIndexName(String schemaName, String indexName); static final String PRODUCT_NAME; }### Answer: @Override @Test public void getCurrentDateTimeFunction() { Assert.assertEquals("NOW()", getDatabase().getCurrentDateTimeFunction()); }

### Question: OracleDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return true; } OracleDatabase(); int getPriority(); @Override void setConnection(DatabaseConnection conn); String getTypeName(); @Override String generatePrimaryKeyName(String tableName); boolean supportsInitiallyDeferrableColumns(); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String objectName); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String escapeIndexName(String schemaName, String indexName); @Override String getDateLiteral(String isoDate); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean shouldQuoteValue(String value); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override boolean supportsRestrictForeignKeys(); static final String PRODUCT_NAME; }### Answer: @Override @Test public void supportsInitiallyDeferrableColumns() { assertTrue(getDatabase().supportsInitiallyDeferrableColumns()); }

### Question: OracleDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "SYSTIMESTAMP"; } OracleDatabase(); int getPriority(); @Override void setConnection(DatabaseConnection conn); String getTypeName(); @Override String generatePrimaryKeyName(String tableName); boolean supportsInitiallyDeferrableColumns(); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String objectName); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String escapeIndexName(String schemaName, String indexName); @Override String getDateLiteral(String isoDate); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean shouldQuoteValue(String value); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override boolean supportsRestrictForeignKeys(); static final String PRODUCT_NAME; }### Answer: @Override @Test public void getCurrentDateTimeFunction() { Assert.assertEquals("SYSTIMESTAMP", getDatabase().getCurrentDateTimeFunction()); }

### Question: SybaseDatabase extends AbstractDatabase { boolean isSybaseProductName(String dbProductName) { return "Adaptive Server Enterprise".equals(dbProductName) || "Sybase SQL Server".equals(dbProductName) || "sql server".equals(dbProductName) || "ASE".equals(dbProductName); } SybaseDatabase(); String getProductName(); String getTypeName(); int getPriority(); @Override boolean supportsDDLInTransaction(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override boolean supportsRestrictForeignKeys(); @Override String escapeDatabaseObject(String objectName); @Override String getViewDefinition(String schemaName, String viewName); @Override int getDatabaseMajorVersion(); @Override int getDatabaseMinorVersion(); @Override String escapeIndexName(String schemaName, String indexName); static final String PRODUCT_NAME; }### Answer: @Test public void testIsSybaseProductName() { SybaseDatabase database = new SybaseDatabase(); assertTrue("Sybase SQL Server is a valid product name", database.isSybaseProductName("Sybase SQL Server")); assertTrue("sql server is a valid product name", database.isSybaseProductName("sql server")); assertTrue("ASE is a valid product name", database.isSybaseProductName("ASE")); assertTrue("Adaptive Server Enterprise is a valid product name", database.isSybaseProductName("Adaptive Server Enterprise")); }

### Question: H2Database extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return false; } H2Database(); String getTypeName(); String getDefaultDriver(String url); int getPriority(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsTablespaces(); @Override String getViewDefinition(String schemaName, String name); @Override Date parseDate(String dateAsString); @Override boolean isLocalDatabase(); @Override boolean supportsSequences(); @Override String getConcatSql(String... values); @Override String getDateLiteral(String isoDate); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String objectName); boolean supportsInitiallyDeferrableColumns(); String getCurrentDateTimeFunction(); }### Answer: @Override @Test public void supportsInitiallyDeferrableColumns() { assertFalse(getDatabase().supportsInitiallyDeferrableColumns()); }

### Question: H2Database extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "NOW()"; } H2Database(); String getTypeName(); String getDefaultDriver(String url); int getPriority(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsTablespaces(); @Override String getViewDefinition(String schemaName, String name); @Override Date parseDate(String dateAsString); @Override boolean isLocalDatabase(); @Override boolean supportsSequences(); @Override String getConcatSql(String... values); @Override String getDateLiteral(String isoDate); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String objectName); boolean supportsInitiallyDeferrableColumns(); String getCurrentDateTimeFunction(); }### Answer: @Override @Test public void getCurrentDateTimeFunction() { Assert.assertEquals("NOW()", getDatabase().getCurrentDateTimeFunction()); }

### Question: H2Database extends AbstractDatabase { public String getDefaultDriver(String url) { if (url.startsWith("jdbc:h2")) { return "org.h2.Driver"; } return null; } H2Database(); String getTypeName(); String getDefaultDriver(String url); int getPriority(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsTablespaces(); @Override String getViewDefinition(String schemaName, String name); @Override Date parseDate(String dateAsString); @Override boolean isLocalDatabase(); @Override boolean supportsSequences(); @Override String getConcatSql(String... values); @Override String getDateLiteral(String isoDate); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String objectName); boolean supportsInitiallyDeferrableColumns(); String getCurrentDateTimeFunction(); }### Answer: @Test public void testGetDefaultDriver() { Database database = getDatabase(); assertEquals("org.h2.Driver", database.getDefaultDriver("jdbc:h2:mem:liquibase")); assertNull(database.getDefaultDriver("jdbc:db2: }

### Question: MySQLDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return false; } String getTypeName(); int getPriority(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); @Override boolean supportsSequences(); boolean supportsInitiallyDeferrableColumns(); String getCurrentDateTimeFunction(); @Override String getLineComment(); @Override String getConcatSql(String ... values); boolean supportsTablespaces(); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override String escapeIndexName(String schemaName, String indexName); @Override boolean supportsForeignKeyDisable(); @Override boolean disableForeignKeyChecks(); @Override void enableForeignKeyChecks(); static final String PRODUCT_NAME; }### Answer: @Override @Test public void supportsInitiallyDeferrableColumns() { assertFalse(getDatabase().supportsInitiallyDeferrableColumns()); }

### Question: MySQLDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "NOW()"; } String getTypeName(); int getPriority(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); @Override boolean supportsSequences(); boolean supportsInitiallyDeferrableColumns(); String getCurrentDateTimeFunction(); @Override String getLineComment(); @Override String getConcatSql(String ... values); boolean supportsTablespaces(); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override String escapeIndexName(String schemaName, String indexName); @Override boolean supportsForeignKeyDisable(); @Override boolean disableForeignKeyChecks(); @Override void enableForeignKeyChecks(); static final String PRODUCT_NAME; }### Answer: @Override @Test public void getCurrentDateTimeFunction() { Assert.assertEquals("NOW()", getDatabase().getCurrentDateTimeFunction()); }

### Question: MSSQLDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return false; } MSSQLDatabase(); String getTypeName(); int getPriority(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); @Override String escapeIndexName(String schemaName, String indexName); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String escapeDatabaseObject(String objectName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String getDateLiteral(String isoDate); @Override boolean supportsRestrictForeignKeys(); @Override boolean supportsDropTableCascadeConstraints(); @Override String getDefaultSchemaName(); @Override String getViewDefinition(String schemaName, String viewName); static final String PRODUCT_NAME; }### Answer: @Override @Test public void supportsInitiallyDeferrableColumns() { assertFalse(getDatabase().supportsInitiallyDeferrableColumns()); }

### Question: MSSQLDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "GETDATE()"; } MSSQLDatabase(); String getTypeName(); int getPriority(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); @Override String escapeIndexName(String schemaName, String indexName); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String escapeDatabaseObject(String objectName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String getDateLiteral(String isoDate); @Override boolean supportsRestrictForeignKeys(); @Override boolean supportsDropTableCascadeConstraints(); @Override String getDefaultSchemaName(); @Override String getViewDefinition(String schemaName, String viewName); static final String PRODUCT_NAME; }### Answer: @Override @Test public void getCurrentDateTimeFunction() { Assert.assertEquals("GETDATE()", getDatabase().getCurrentDateTimeFunction()); }

### Question: MSSQLDatabase extends AbstractDatabase { public String getDefaultDriver(String url) { if (url.startsWith("jdbc:sqlserver")) { return "com.microsoft.sqlserver.jdbc.SQLServerDriver"; } else if (url.startsWith("jdbc:jtds:sqlserver")) { return "net.sourceforge.jtds.jdbc.Driver"; } return null; } MSSQLDatabase(); String getTypeName(); int getPriority(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); @Override String escapeIndexName(String schemaName, String indexName); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String escapeDatabaseObject(String objectName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String getDateLiteral(String isoDate); @Override boolean supportsRestrictForeignKeys(); @Override boolean supportsDropTableCascadeConstraints(); @Override String getDefaultSchemaName(); @Override String getViewDefinition(String schemaName, String viewName); static final String PRODUCT_NAME; }### Answer: @Test public void getDefaultDriver() { Database database = new MSSQLDatabase(); assertEquals("com.microsoft.sqlserver.jdbc.SQLServerDriver", database.getDefaultDriver("jdbc:sqlserver: assertNull(database.getDefaultDriver("jdbc:oracle:thin: }

### Question: MSSQLDatabase extends AbstractDatabase { @Override public String getDefaultSchemaName() { String defaultSchemaName = super.getDefaultSchemaName(); if (defaultSchemaName == null) { return "dbo"; } else { return defaultSchemaName; } } MSSQLDatabase(); String getTypeName(); int getPriority(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); @Override String escapeIndexName(String schemaName, String indexName); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String escapeDatabaseObject(String objectName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String getDateLiteral(String isoDate); @Override boolean supportsRestrictForeignKeys(); @Override boolean supportsDropTableCascadeConstraints(); @Override String getDefaultSchemaName(); @Override String getViewDefinition(String schemaName, String viewName); static final String PRODUCT_NAME; }### Answer: @Test public void changeDefaultSchema() throws DatabaseException { Database database = new MSSQLDatabase(); assertEquals("dbo", database.getDefaultSchemaName()); database.setDefaultSchemaName("myschema"); assertEquals("myschema", database.getDefaultSchemaName()); }

### Question: DatabaseFactory { public static DatabaseFactory getInstance() { if (instance == null) { instance = new DatabaseFactory(); } return instance; } protected DatabaseFactory(); static DatabaseFactory getInstance(); static void reset(); List<Database> getImplementedDatabases(); void register(Database database); Database findCorrectDatabaseImplementation(DatabaseConnection connection); String findDefaultDriver(String url); void clearRegistry(); }### Answer: @Test public void getInstance() { assertNotNull(DatabaseFactory.getInstance()); }

### Question: TypeConverterFactory { public TypeConverter findTypeConverter(Database database) { SortedSet<TypeConverter> converters = new TreeSet<TypeConverter>(new Comparator<TypeConverter>() { public int compare(TypeConverter o1, TypeConverter o2) { return Integer.valueOf(o1.getPriority()).compareTo(o2.getPriority()); } }); for (TypeConverter converter : allConverters) { if (converter.supports(database)) { converters.add(converter); } } return converters.last(); } private TypeConverterFactory(); static TypeConverterFactory getInstance(); TypeConverter findTypeConverter(Database database); void register(TypeConverter typeConverter); void register(Class<? extends TypeConverter> typeConverterClass); }### Answer: @Test public void findTypeConverter() { assertTrue(TypeConverterFactory.getInstance().findTypeConverter(new UnsupportedDatabase()) instanceof DefaultTypeConverter); assertTrue(TypeConverterFactory.getInstance().findTypeConverter(new H2Database()) instanceof H2TypeConverter); }

### Question: OracleTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType("NUMBER(1)"); } int getPriority(); boolean supports(Database database); @Override String convertToDatabaseTypeString(Column referenceColumn, Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override TimeType getTimeType(); @Override DateTimeType getDateTimeType(); @Override BigIntType getBigIntType(); @Override IntType getIntType(); @Override VarcharType getVarcharType(); @Override NVarcharType getNVarcharType(); @Override DoubleType getDoubleType(); @Override TinyIntType getTinyIntType(); }### Answer: @Test public void getBooleanType() { assertEquals("NUMBER(1)", new OracleTypeConverter().getBooleanType().toString()); }

### Question: OracleTypeConverter extends AbstractTypeConverter { @Override public CurrencyType getCurrencyType() { return new CurrencyType("NUMBER(15, 2)"); } int getPriority(); boolean supports(Database database); @Override String convertToDatabaseTypeString(Column referenceColumn, Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override TimeType getTimeType(); @Override DateTimeType getDateTimeType(); @Override BigIntType getBigIntType(); @Override IntType getIntType(); @Override VarcharType getVarcharType(); @Override NVarcharType getNVarcharType(); @Override DoubleType getDoubleType(); @Override TinyIntType getTinyIntType(); }### Answer: @Test public void getCurrencyType() { assertEquals("NUMBER(15, 2)", new OracleTypeConverter().getCurrencyType().toString()); }

### Question: OracleTypeConverter extends AbstractTypeConverter { @Override public UUIDType getUUIDType() { return new UUIDType("RAW(16)"); } int getPriority(); boolean supports(Database database); @Override String convertToDatabaseTypeString(Column referenceColumn, Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override TimeType getTimeType(); @Override DateTimeType getDateTimeType(); @Override BigIntType getBigIntType(); @Override IntType getIntType(); @Override VarcharType getVarcharType(); @Override NVarcharType getNVarcharType(); @Override DoubleType getDoubleType(); @Override TinyIntType getTinyIntType(); }### Answer: @Test public void getUUIDType() { assertEquals("RAW(16)", new OracleTypeConverter().getUUIDType().toString()); }

### Question: OracleTypeConverter extends AbstractTypeConverter { @Override public DateTimeType getDateTimeType() { return new DateTimeType("TIMESTAMP"); } int getPriority(); boolean supports(Database database); @Override String convertToDatabaseTypeString(Column referenceColumn, Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override TimeType getTimeType(); @Override DateTimeType getDateTimeType(); @Override BigIntType getBigIntType(); @Override IntType getIntType(); @Override VarcharType getVarcharType(); @Override NVarcharType getNVarcharType(); @Override DoubleType getDoubleType(); @Override TinyIntType getTinyIntType(); }### Answer: @Test public void getDateTimeType() { assertEquals("TIMESTAMP", new OracleTypeConverter().getDateTimeType().toString()); }

### Question: MSSQLTypeConverter extends AbstractTypeConverter { @Override public BlobType getBlobType() { return new BlobType("VARBINARY(MAX)"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }### Answer: @Test public void getBlobType() { assertEquals("VARBINARY(MAX)", new MSSQLTypeConverter().getBlobType().toString()); }

### Question: MSSQLTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType("BIT"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }### Answer: @Test public void getBooleanType() { assertEquals("BIT", new MSSQLTypeConverter().getBooleanType().toString()); }

### Question: MSSQLTypeConverter extends AbstractTypeConverter { @Override public CurrencyType getCurrencyType() { return new CurrencyType("MONEY"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }### Answer: @Test public void getCurrencyType() { assertEquals("MONEY", new MSSQLTypeConverter().getCurrencyType().toString()); }

### Question: MSSQLTypeConverter extends AbstractTypeConverter { @Override public UUIDType getUUIDType() { return new UUIDType("UNIQUEIDENTIFIER"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }### Answer: @Test public void getUUIDType() { assertEquals("UNIQUEIDENTIFIER", new MSSQLTypeConverter().getUUIDType().toString()); }

### Question: MSSQLTypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("NVARCHAR(MAX)"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }### Answer: @Test public void getClobType() { assertEquals("NVARCHAR(MAX)", new MSSQLTypeConverter().getClobType().toString()); }

### Question: MSSQLTypeConverter extends AbstractTypeConverter { @Override public DateType getDateType() { return new DateType("SMALLDATETIME"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }### Answer: @Test public void getDateType() { assertEquals("SMALLDATETIME", new MSSQLTypeConverter().getDateType().toString()); }

### Question: MSSQLTypeConverter extends AbstractTypeConverter { @Override public NumberType getNumberType() { return new NumberType("NUMERIC"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }### Answer: @Test public void getNumberType() { assertEquals("NUMERIC", new MSSQLTypeConverter().getNumberType().toString()); }

### Question: PostgresTypeConverter extends AbstractTypeConverter { @Override public BlobType getBlobType() { return new BlobType("BYTEA"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }### Answer: @Test public void getBlobType() { assertEquals("BYTEA", new PostgresTypeConverter().getBlobType().toString()); }

### Question: PostgresTypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("TEXT"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }### Answer: @Test public void getClobType() { assertEquals("TEXT", new PostgresTypeConverter().getClobType().toString()); }

### Question: PostgresTypeConverter extends AbstractTypeConverter { @Override public DateTimeType getDateTimeType() { return new DateTimeType("TIMESTAMP WITH TIME ZONE"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }### Answer: @Test public void getDateTimeType() { assertEquals("TIMESTAMP WITH TIME ZONE", new PostgresTypeConverter().getDateTimeType().toString()); }

### Question: H2TypeConverter extends AbstractTypeConverter { @Override public BlobType getBlobType() { return new BlobType("LONGVARBINARY"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DateTimeType getDateTimeType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); }### Answer: @Test public void getBlobType() { assertEquals("LONGVARBINARY", new H2TypeConverter().getBlobType().toString()); }

### Question: H2TypeConverter extends AbstractTypeConverter { @Override public UUIDType getUUIDType() { return new UUIDType("UUID"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DateTimeType getDateTimeType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); }### Answer: @Test public void getUUIDType() { assertEquals("UUID", new H2TypeConverter().getUUIDType().toString()); }

### Question: H2TypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("LONGVARCHAR"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DateTimeType getDateTimeType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); }### Answer: @Test public void getClobType() { assertEquals("LONGVARCHAR", new H2TypeConverter().getClobType().toString()); }

### Question: H2TypeConverter extends AbstractTypeConverter { @Override public DateTimeType getDateTimeType() { return new DateTimeType("TIMESTAMP"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DateTimeType getDateTimeType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); }### Answer: @Test public void getDateTimeType() { assertEquals("TIMESTAMP", new H2TypeConverter().getDateTimeType().toString()); }

### Question: CacheTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType(); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BlobType getBlobType(); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override CurrencyType getCurrencyType(); }### Answer: @Test public void getFalseBooleanValue() { assertEquals("0", new CacheTypeConverter().getBooleanType().getFalseBooleanValue()); } @Test public void getTrueBooleanValue() { assertEquals("1", new CacheTypeConverter().getBooleanType().getTrueBooleanValue()); } @Test public void getBooleanType() { assertEquals("INT", new CacheTypeConverter().getBooleanType().toString()); }

### Question: CacheTypeConverter extends AbstractTypeConverter { @Override public BlobType getBlobType() { return new BlobType("LONGVARBINARY"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BlobType getBlobType(); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override CurrencyType getCurrencyType(); }### Answer: @Test public void getBlobType() { assertEquals("LONGVARBINARY", new CacheTypeConverter().getBlobType().toString()); }

### Question: CacheTypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("LONGVARCHAR"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BlobType getBlobType(); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override CurrencyType getCurrencyType(); }### Answer: @Test public void getClobType() { assertEquals("LONGVARCHAR", new CacheTypeConverter().getClobType().toString()); }

### Question: CacheTypeConverter extends AbstractTypeConverter { @Override public CurrencyType getCurrencyType() { return new CurrencyType("MONEY"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BlobType getBlobType(); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override CurrencyType getCurrencyType(); }### Answer: @Test public void getCurrencyType() { assertEquals("MONEY", new CacheTypeConverter().getCurrencyType().toString()); }

### Question: MySQLTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType("TINYINT(1)"); } int getPriority(); boolean supports(Database database); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override BlobType getLongBlobType(); @Override NumberType getNumberType(); }### Answer: @Test public void getBooleanType() { assertEquals("TINYINT(1)", new MySQLTypeConverter().getBooleanType().toString()); }

### Question: MySQLTypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("LONGTEXT"); } int getPriority(); boolean supports(Database database); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override BlobType getLongBlobType(); @Override NumberType getNumberType(); }### Answer: @Test public void getClobType() { assertEquals("LONGTEXT", new MySQLTypeConverter().getClobType().toString()); }

### Question: ChangeLogSerializerFactory { public static ChangeLogSerializerFactory getInstance() { if (instance == null) { instance = new ChangeLogSerializerFactory(); } return instance; } private ChangeLogSerializerFactory(); static void reset(); static ChangeLogSerializerFactory getInstance(); Map<String, ChangeLogSerializer> getSerializers(); ChangeLogSerializer getSerializer(String fileNameOrExtension); void register(ChangeLogSerializer changeLogSerializer); void unregister(ChangeLogSerializer changeLogSerializer); }### Answer: @Test public void getInstance() { assertNotNull(ChangeLogSerializerFactory.getInstance()); assertTrue(ChangeLogSerializerFactory.getInstance() == ChangeLogSerializerFactory.getInstance()); }

### Question: ChangeLogSerializerFactory { public void register(ChangeLogSerializer changeLogSerializer) { for (String extension : changeLogSerializer.getValidFileExtensions()) { serializers.put(extension, changeLogSerializer); } } private ChangeLogSerializerFactory(); static void reset(); static ChangeLogSerializerFactory getInstance(); Map<String, ChangeLogSerializer> getSerializers(); ChangeLogSerializer getSerializer(String fileNameOrExtension); void register(ChangeLogSerializer changeLogSerializer); void unregister(ChangeLogSerializer changeLogSerializer); }### Answer: @Test public void register() { ChangeLogSerializerFactory.getInstance().getSerializers().clear(); assertEquals(0, ChangeLogSerializerFactory.getInstance().getSerializers().size()); ChangeLogSerializerFactory.getInstance().register(new MockChangeLogSerializer("mock")); assertEquals(1, ChangeLogSerializerFactory.getInstance().getSerializers().size()); }

### Question: ChangeLogSerializerFactory { public static void reset() { instance = new ChangeLogSerializerFactory(); } private ChangeLogSerializerFactory(); static void reset(); static ChangeLogSerializerFactory getInstance(); Map<String, ChangeLogSerializer> getSerializers(); ChangeLogSerializer getSerializer(String fileNameOrExtension); void register(ChangeLogSerializer changeLogSerializer); void unregister(ChangeLogSerializer changeLogSerializer); }### Answer: @Test public void reset() { ChangeLogSerializerFactory instance1 = ChangeLogSerializerFactory.getInstance(); ChangeLogSerializerFactory.reset(); assertFalse(instance1 == ChangeLogSerializerFactory.getInstance()); }

### Question: ChangeLogSerializerFactory { public Map<String, ChangeLogSerializer> getSerializers() { return serializers; } private ChangeLogSerializerFactory(); static void reset(); static ChangeLogSerializerFactory getInstance(); Map<String, ChangeLogSerializer> getSerializers(); ChangeLogSerializer getSerializer(String fileNameOrExtension); void register(ChangeLogSerializer changeLogSerializer); void unregister(ChangeLogSerializer changeLogSerializer); }### Answer: @Test public void getSerializers() { ChangeLogSerializer serializer = ChangeLogSerializerFactory.getInstance().getSerializer("xml"); assertNotNull(serializer); assertTrue(serializer instanceof XMLChangeLogSerializer); }

### Question: PrintPreview { public int determineHeight() { int height = 0; for (PrintRow row : processRowsBeforePreviewing(printPayload.getRows())) { if (row instanceof TextRow) { PrinterFont font = getFont(((TextRow) row).getPrinterFontId()); height += font.getLineHeight(); } else if (row instanceof ImageRow) { height += ((ImageRow) row).getImage().getHeight() + VERTICAL_MARGIN * 2; } } return height + VERTICAL_MARGIN * 2; } PrintPreview(PrintPayload printPayload, PrinterSettings printerSettings); Bitmap getBitmap(); Bitmap getScaledBitmap(Context context); byte[] getCompressedBitmap(); int determineHeight(); }### Answer: @Test public void canDetermineHeight() { PrintPayload payload = new PrintPayload(); payload.append("Line1"); payload.append("Line2"); payload.append("Line3"); payload.append("Line4"); PrintPreview printPreview = new PrintPreview(payload, getPrinterSettings()); assertThat(printPreview.determineHeight()).isEqualTo(144); }

### Question: PrintPayload implements Jsonable { public TextRow append(String text) { return append(text, null); } PrintPayload(); PrintPayload(String printerId); TextRow append(String text); TextRow append(String text, PrinterFont printerFont); void append(PrintPayload toAppendPayload); void appendEmptyLine(); TextRow appendLineOfChar(int columns, String character); TextRow appendLeftRight(int columns, String left, String right); ImageRow append(Bitmap image); ImageRow append(Bitmap image, boolean scaleToFit); PrintRow[] getRows(); int getCodePage(); void setCodePage(int codePage); String getLanguage(); void setLanguage(String languageCode); void setPrinterId(String printerId); String getPrinterId(); boolean hasPrinterId(); @Override String toJson(); static PrintPayload fromJson(String json); }### Answer: @Test(expected = IllegalArgumentException.class) public void appendNullImageWillThrow() { PrintPayload payload = new PrintPayload(); payload.append((Bitmap) null); } @Test(expected = IllegalArgumentException.class) public void appendNullPayloadWillThrow() { PrintPayload payload = new PrintPayload(); payload.append((PrintPayload) null); } @Test public void canSetFont() { PrintPayload payload = new PrintPayload(); PrinterFont printerFont = new PrinterFont(56, "FontyMcFontFace", 0, 0, false, 0, 0, null); TextRow textRow = payload.append("Hello", printerFont); assertThat(textRow.getPrinterFontId()).isEqualTo(56); } @Test public void canSetImageScale() { PrintPayload payload = new PrintPayload(); Bitmap bmp = getBitmap(); ImageRow imageRow = payload.append(bmp, true); assertThat(imageRow.isScaleToFit()).isTrue(); } @Test(expected = IllegalArgumentException.class) public void appendNullWillThrow() { PrintPayload payload = new PrintPayload(); payload.append((String) null); }

### Question: PrintPreview { public Bitmap getBitmap() { return bitmap; } PrintPreview(PrintPayload printPayload, PrinterSettings printerSettings); Bitmap getBitmap(); Bitmap getScaledBitmap(Context context); byte[] getCompressedBitmap(); int determineHeight(); }### Answer: @Test public void canGetBitmap() { PrintPreview printPreview = setupValidPrintPreview(true); ShadowBitmap bitmap = Shadows.shadowOf(printPreview.getBitmap()); assertThat(bitmap).isNotNull(); assertThat(bitmap.getDescription()).isEqualTo("Bitmap (576 x 48)\n" + "Bitmap (9 x 32)"); assertThat(printPreview.availableWidth).isEqualTo(576); }

### Question: PrintPreview { public Bitmap getScaledBitmap(Context context) { cursor = VERTICAL_MARGIN; DisplayMetrics metrics = context.getResources().getDisplayMetrics(); Bitmap bitmap = getBitmap(); float pxPerMm = metrics.xdpi / 25.4f; int width = bitmap.getWidth(); float scale = (printerSettings.getPrintableWidth() * pxPerMm) / (float) width; return Bitmap.createScaledBitmap(bitmap, (int) (bitmap.getWidth() * scale), (int) (bitmap.getHeight() * scale), true); } PrintPreview(PrintPayload printPayload, PrinterSettings printerSettings); Bitmap getBitmap(); Bitmap getScaledBitmap(Context context); byte[] getCompressedBitmap(); int determineHeight(); }### Answer: @Test public void canGetScaledBitmap() { PrintPreview printPreview = setupValidPrintPreview(true); ShadowBitmap bitmap = Shadows.shadowOf(printPreview.getScaledBitmap(RuntimeEnvironment.application)); assertThat(bitmap).isNotNull(); assertThat(bitmap.getDescription()).isEqualTo("Bitmap (576 x 48)\n" + "Bitmap (9 x 32) scaled to 708 x 59 with filter true"); } @Test public void handlesNoFonts() { PrintPreview printPreview = setupValidPrintPreview(false); Bitmap bitmap = printPreview.getScaledBitmap(RuntimeEnvironment.application); assertThat(bitmap).isNotNull(); }

### Question: PrintPreview { protected List<TextRow> splitLongTextRow(TextRow textRow) { List<TextRow> result = new ArrayList<>(); PrinterFont font = getFont(textRow.getPrinterFontId()); String line = textRow.getText(); String remaining = ""; while (line.length() > 0) { if (line.length() > font.getNumColumns()) { remaining = line.charAt(line.length() - 1) + remaining; line = line.substring(0, line.length() - 1); } else { TextRow newRow = new TextRow(line) .align(textRow.getAlignmentStyle()) .fontStyle(textRow.getFontStyle()) .underline(textRow.getUnderlineStyle()) .setFont(font); result.add(newRow); line = remaining; remaining = ""; } } return result; } PrintPreview(PrintPayload printPayload, PrinterSettings printerSettings); Bitmap getBitmap(); Bitmap getScaledBitmap(Context context); byte[] getCompressedBitmap(); int determineHeight(); }### Answer: @Test public void willSplitLongLineCorrectly() { PrintPayload payload = new PrintPayload(); TextRow row = payload.append("this is a very long line of text that should be split across multiple lines"); PrintPreview printPreview = new PrintPreview(payload, getPrinterSettings()); List<TextRow> rows = printPreview.splitLongTextRow(row); assertThat(rows).hasSize(2); assertThat(rows.get(0).getText()).isEqualTo("this is a very long line of text that should be "); assertThat(rows.get(1).getText()).isEqualTo("split across multiple lines"); assertThat(rows.get(0).getText().length()).isLessThanOrEqualTo(FONT_A.getNumColumns()); assertThat(rows.get(1).getText().length()).isLessThanOrEqualTo(FONT_A.getNumColumns()); }

### Question: PrintPayload implements Jsonable { public String getPrinterId() { return printerId; } PrintPayload(); PrintPayload(String printerId); TextRow append(String text); TextRow append(String text, PrinterFont printerFont); void append(PrintPayload toAppendPayload); void appendEmptyLine(); TextRow appendLineOfChar(int columns, String character); TextRow appendLeftRight(int columns, String left, String right); ImageRow append(Bitmap image); ImageRow append(Bitmap image, boolean scaleToFit); PrintRow[] getRows(); int getCodePage(); void setCodePage(int codePage); String getLanguage(); void setLanguage(String languageCode); void setPrinterId(String printerId); String getPrinterId(); boolean hasPrinterId(); @Override String toJson(); static PrintPayload fromJson(String json); }### Answer: @Test public void willSetPrinterId() { PrintPayload payload = new PrintPayload("17676767"); assertThat(payload.getPrinterId()).isEqualTo("17676767"); }

### Question: PrintPayload implements Jsonable { public TextRow appendLeftRight(int columns, String left, String right) { String space = getSpaces(columns - left.length() - right.length()); return append(left + space + right); } PrintPayload(); PrintPayload(String printerId); TextRow append(String text); TextRow append(String text, PrinterFont printerFont); void append(PrintPayload toAppendPayload); void appendEmptyLine(); TextRow appendLineOfChar(int columns, String character); TextRow appendLeftRight(int columns, String left, String right); ImageRow append(Bitmap image); ImageRow append(Bitmap image, boolean scaleToFit); PrintRow[] getRows(); int getCodePage(); void setCodePage(int codePage); String getLanguage(); void setLanguage(String languageCode); void setPrinterId(String printerId); String getPrinterId(); boolean hasPrinterId(); @Override String toJson(); static PrintPayload fromJson(String json); }### Answer: @Test public void checkAlignLeftRight() { PrintPayload payload = new PrintPayload(); TextRow row = payload.appendLeftRight(30, "Left", "Right"); assertThat(row.getText()).isEqualTo("Left Right"); }

### Question: PrintPayload implements Jsonable { public TextRow appendLineOfChar(int columns, String character) { String line = character; while (line.length() < columns) { line += character; } return append(line); } PrintPayload(); PrintPayload(String printerId); TextRow append(String text); TextRow append(String text, PrinterFont printerFont); void append(PrintPayload toAppendPayload); void appendEmptyLine(); TextRow appendLineOfChar(int columns, String character); TextRow appendLeftRight(int columns, String left, String right); ImageRow append(Bitmap image); ImageRow append(Bitmap image, boolean scaleToFit); PrintRow[] getRows(); int getCodePage(); void setCodePage(int codePage); String getLanguage(); void setLanguage(String languageCode); void setPrinterId(String printerId); String getPrinterId(); boolean hasPrinterId(); @Override String toJson(); static PrintPayload fromJson(String json); }### Answer: @Test public void checkAppendLineOfChar() { PrintPayload payload = new PrintPayload(); TextRow row = payload.appendLineOfChar(30, "="); assertThat(row.getText()).isEqualTo("=============================="); }

### Question: MessengerChannelServer extends BaseChannelServer { @Override public boolean send(MessageException error) { Bundle b = new Bundle(); b.putString(KEY_DATA_RESPONSE, error.toJson()); Message message = createMessage(b, MESSAGE_ERROR); return send(message); } MessengerChannelServer(String serviceComponentName, String clientPackageName); @Override void handleMessage(Message msg); @Override void disposeClient(); @Override boolean send(MessageException error); @Override String getClientPackageName(); @Override boolean send(String senddata); @Override boolean sendEndStream(); }### Answer: @Test public void willSendMessage() throws RemoteException { setupReplyTo(); String message = "hellooooooo"; boolean sent = messengerChannelServer.send(message); assertThat(sent).isTrue(); verifySentMessage(MESSAGE_RESPONSE, message); } @Test public void willSendExceptionMessage() throws RemoteException { setupReplyTo(); MessageException message = new MessageException("bleep", "bloop"); boolean sent = messengerChannelServer.send(message); assertThat(sent).isTrue(); verifySentMessage(MESSAGE_ERROR, message.toJson()); }

### Question: ObservableWebSocketClient extends ObservableMessengerClient { @Override public Observable<String> sendMessage(final String message) { if (!super.isConnected()) { return connectAndSendMessage(message); } else { if (responseEmitter == null || responseEmitter.hasComplete()) { responseEmitter = PublishSubject.create(); } if (okWebSocketClient != null && okWebSocketClient.isConnected()) { okWebSocketClient.updateCallbackEmitter(responseEmitter); okWebSocketClient.sendMessage(message); } else { super.sendMessage(message); } return responseEmitter; } } ObservableWebSocketClient(Context context, ComponentName serviceComponentName); @Override Completable connect(); @Override boolean isConnected(); @Override Observable<String> sendMessage(final String message); @Override void closeConnection(); }### Answer: @Test public void willSendMessageViaWebsocket() throws RemoteException { setupMockBoundMessengerService(); createObservableSendDataAndSubscribe("hellooooo"); sendConnectionParamsFromServer(); setWebSocketConnectedState(true); observableWebSocketClient.sendMessage("This is ground control to Major Tom").test(); verify(observableWebSocketClient.okWebSocketClient).sendMessage("This is ground control to Major Tom"); } @Test public void willFallbackToMessengerIfNotConnected() throws RemoteException { setupMockBoundMessengerService(); createObservableSendDataAndSubscribe("connect with me"); sendConnectionParamsFromServer(); setWebSocketConnectedState(false); observableWebSocketClient.sendMessage("Stop messaging me").test(); verify(observableWebSocketClient.okWebSocketClient, times(0)).sendMessage(anyString()); verifyMessagesSentToServerViaMessenger(2); }

### Question: ObservableWebSocketClient extends ObservableMessengerClient { @Override public void closeConnection() { if (okWebSocketClient != null && okWebSocketClient.isConnected()) { okWebSocketClient.close(); } super.closeConnection(); } ObservableWebSocketClient(Context context, ComponentName serviceComponentName); @Override Completable connect(); @Override boolean isConnected(); @Override Observable<String> sendMessage(final String message); @Override void closeConnection(); }### Answer: @Test public void willCloseWebSocket() throws RemoteException { setupMockBoundMessengerService(); createObservableSendDataAndSubscribe("lets connect"); sendConnectionParamsFromServer(); setWebSocketConnectedState(true); observableWebSocketClient.closeConnection(); verify(observableWebSocketClient.okWebSocketClient).close(); }

### Question: MessengerChannelServer extends BaseChannelServer { @Override public boolean sendEndStream() { Message message = createMessage(null, MESSAGE_END_STREAM); closeClient(); return send(message); } MessengerChannelServer(String serviceComponentName, String clientPackageName); @Override void handleMessage(Message msg); @Override void disposeClient(); @Override boolean send(MessageException error); @Override String getClientPackageName(); @Override boolean send(String senddata); @Override boolean sendEndStream(); }### Answer: @Test public void willSendEndMessage() throws RemoteException { setupReplyTo(); boolean sent = messengerChannelServer.sendEndStream(); assertThat(sent).isTrue(); verifySentMessage(MESSAGE_END_STREAM, null); }

### Question: WebSocketChannelServer extends MessengerChannelServer { private void startServer() { setupSendQueue(); setupWebServer(); } WebSocketChannelServer(Context context, String serviceComponentName, String clientPackageName); @Override void handleMessage(Message msg); @Override boolean send(final String message); @Override boolean sendEndStream(); static final String CONNECT_PLEASE; static final String CLOSE_MESSAGE; }### Answer: @Test public void willStartServerOnFirstMessage() { setupWebserverConnectionNever(); sendFirstMessage(); verify(webSocketServer).startServer(); }

### Question: WebSocketChannelServer extends MessengerChannelServer { @Override public boolean sendEndStream() { disconnectedWithEndStreamCall = true; sendMessageQueue.onNext(CLOSE_MESSAGE); Observable.timer(WAIT_FOR_CLOSE_TIMEOUT, TimeUnit.SECONDS, getSendScheduler()) .subscribe(new Consumer<Long>() { @Override public void accept(Long aLong) throws Exception { if (!sendMessageQueue.hasComplete()) { sendMessageQueue.onComplete(); } } }); return true; } WebSocketChannelServer(Context context, String serviceComponentName, String clientPackageName); @Override void handleMessage(Message msg); @Override boolean send(final String message); @Override boolean sendEndStream(); static final String CONNECT_PLEASE; static final String CLOSE_MESSAGE; }### Answer: @Test public void willDisconnectOnEndStream() { setupWebserverConnection(); sendFirstMessage(); webSocketChannelServer.sendEndStream(); verify(webSocketConnection).disconnect(); }

### Question: WebSocketChannelServer extends MessengerChannelServer { @Override public boolean send(final String message) { if (webSocketConnection != null && webSocketConnection.isConnected()) { sendMessageQueue.onNext(message); return true; } else { return super.send(message); } } WebSocketChannelServer(Context context, String serviceComponentName, String clientPackageName); @Override void handleMessage(Message msg); @Override boolean send(final String message); @Override boolean sendEndStream(); static final String CONNECT_PLEASE; static final String CLOSE_MESSAGE; }### Answer: @Test public void canSendMessageToClient() throws IOException { setupWebserverConnection(); sendFirstMessage(); String msg = "Hello client, are you are ok?"; webSocketChannelServer.send(msg); verify(webSocketConnection).send(msg); }

### Question: AbstractChannelService extends Service { @Override @NonNull public final IBinder onBind(Intent intent) { String clientId = getClientIdFromIntent(intent); String channelType = getChannelTypeFromIntent(intent); String clientPackageName = getClientPackageNameFromIntent(intent); Log.d(TAG, String.format("Bound to client %s channel type: %s", clientId, channelType)); return createServiceIncomingHandler(clientId, channelType, clientPackageName); } @Override @NonNull final IBinder onBind(Intent intent); @NonNull IBinder createServiceIncomingHandler(String clientId, String channelType, String clientPackageName); void setStopSelfOnEndOfStream(boolean stopSelfOnEndOfStream); @Override boolean onUnbind(Intent intent); @Nullable ChannelServer getChannelServerForId(String clientMessageId); }### Answer: @Test public void willSetupChannelOnFirstMessageIntent() { Intent intent = new Intent(); testAbstractChannelService.onBind(intent); assertThat(testAbstractChannelService.incomingHandler).isNotNull(); testAbstractChannelService.incomingHandler.handleMessage(setupEmptyMessage()); assertThat(testAbstractChannelService.channelServerMap).hasSize(1); assertThat(testAbstractChannelService.channelType).isEqualTo(CHANNEL_MESSENGER); }

### Question: ObservableMessengerClient extends BaseChannelClient implements ChannelClient { public void closeConnection() { if (messengerConnection != null) { Log.d(TAG, "Closing connection with id: " + messengerConnection.getClientId()); try { context.unbindService(messengerConnection); } catch (Throwable t) { } messengerConnection = null; if (responseEmitter != null) { responseEmitter.onComplete(); responseEmitter = null; } } } ObservableMessengerClient(Context context, ComponentName serviceComponentName); ObservableMessengerClient(Context context, ComponentName serviceComponentName, OnHandleMessageCallback onHandleMessageCallback); boolean isConnected(); Completable connect(); Observable<String> sendMessage(final String requestData); void closeConnection(); }### Answer: @Test public void checkCloseConnectionWillUnbindService() throws RemoteException { setupMockBoundMessengerService(); TestObserver<String> obs = createObservableSendDataAndSubscribe(new DataObject()); DataObject response = new DataObject(); sendReply(response); observableMessengerClient.closeConnection(); obs.awaitDone(2000, TimeUnit.MILLISECONDS).assertNoErrors().assertComplete().assertValue(response.toJson()); verifyServiceIsUnbound(); } @Test public void checkWillUseDifferentClientIdsForEachConnection() throws Exception { setupMockBoundMessengerService(); DataObject msg = new DataObject(); createObservableSendDataAndSubscribe(msg); Bundle firstMessage = getReceivedBundle(0); String firstClientId = firstMessage.getString(KEY_CLIENT_ID); observableMessengerClient.closeConnection(); msg = new DataObject(); createObservableSendDataAndSubscribe(msg); Bundle secondMessage = getReceivedBundle(1); String secondClientId = secondMessage.getString(KEY_CLIENT_ID); assertThat(firstClientId).isNotEqualTo(secondClientId); }

### Question: ObservableWebSocketClient extends ObservableMessengerClient { @NonNull protected Intent getServiceIntent(String clientId) { Intent intent = super.getServiceIntent(clientId); intent.putExtra(KEY_CHANNEL_TYPE, CHANNEL_WEBSOCKET); return intent; } ObservableWebSocketClient(Context context, ComponentName serviceComponentName); @Override Completable connect(); @Override boolean isConnected(); @Override Observable<String> sendMessage(final String message); @Override void closeConnection(); }### Answer: @Test public void checkBindIntentWillContainCorrectChannel() { Intent bindIntent = observableWebSocketClient.getServiceIntent("7878"); assertThat(bindIntent).isNotNull(); assertThat(bindIntent.hasExtra(KEY_CHANNEL_TYPE)).isTrue(); assertThat(bindIntent.getStringExtra(KEY_CHANNEL_TYPE)).isEqualTo(CHANNEL_WEBSOCKET); assertThat(bindIntent.hasExtra(KEY_CLIENT_ID)).isTrue(); assertThat(bindIntent.getStringExtra(KEY_CLIENT_ID)).isEqualTo("7878"); }

### Question: BaseHumanName extends BaseResource { public String getDisplayName(){ List<String> names = Arrays.asList(getPrefix(), getGivenName(), getFamilyName(), getSuffix()); return names.stream().filter(Objects::nonNull).collect(Collectors.joining(" ")); } HumanName.NameUse getNameUse(); void setNameUse(HumanName.NameUse nameUse); String getPrefix(); void setPrefix(String prefix); String getGivenName(); void setGivenName(String givenName); String getFamilyName(); void setFamilyName(String familyName); String getSuffix(); void setSuffix(String suffix); String getDisplayName(); @Override Long getId(); }### Answer: @Test public void testDisplayName_Empty(){ BaseHumanName name = new BaseHumanName(); String displayName = name.getDisplayName(); assertThat(displayName, not(nullValue())); assertThat(displayName, equalTo("")); }

### Question: ValidateUtils { public static boolean validateUrl(String urlStr) { Matcher matcher = VALID_URL_REGEX .matcher(urlStr); return matcher.find(); } private ValidateUtils(); static boolean validateEmail(String emailStr); static boolean validateUrl(String urlStr); }### Answer: @Test public void testValidateUrl() { assertTrue(ValidateUtils.validateUrl("https: assertTrue(ValidateUtils.validateUrl("http: assertTrue(ValidateUtils.validateUrl("ftp: assertTrue(ValidateUtils.validateUrl("file: assertTrue(ValidateUtils.validateUrl("https: assertTrue(ValidateUtils.validateUrl("https: assertTrue(ValidateUtils.validateUrl("https: assertTrue(ValidateUtils.validateUrl("https: assertTrue(ValidateUtils.validateUrl("https: assertTrue(ValidateUtils.validateUrl("https: assertTrue(ValidateUtils.validateUrl("https: assertTrue(ValidateUtils.validateUrl("https: assertTrue(ValidateUtils.validateUrl("https: assertTrue(ValidateUtils.validateUrl("https: assertTrue(ValidateUtils.validateUrl("https: assertTrue(ValidateUtils.validateUrl("https: assertFalse(ValidateUtils.validateUrl("")); assertFalse(ValidateUtils.validateUrl("ht: assertFalse(ValidateUtils.validateUrl("http/www.test.com")); assertFalse(ValidateUtils.validateUrl("http: assertFalse(ValidateUtils.validateUrl("http: assertFalse(ValidateUtils.validateUrl("http: assertFalse(ValidateUtils.validateUrl("http56: assertFalse(ValidateUtils.validateUrl("http assertFalse(ValidateUtils.validateUrl("http assertFalse(ValidateUtils.validateUrl("httpstest.com")); assertFalse(ValidateUtils.validateUrl("test")); assertFalse(ValidateUtils.validateUrl("test.co.in")); assertFalse(ValidateUtils.validateUrl(".com")); }

### Question: ValidateUtils { public static boolean validateEmail(String emailStr) { Matcher matcher = VALID_EMAIL_ADDRESS_REGEX .matcher(emailStr); return matcher.find(); } private ValidateUtils(); static boolean validateEmail(String emailStr); static boolean validateUrl(String urlStr); }### Answer: @Test public void testValidateEmail() { assertTrue(ValidateUtils.validateEmail("abcd@efg.com")); assertTrue(ValidateUtils.validateEmail("ABCD@efg.com")); assertTrue(ValidateUtils.validateEmail("abc898d@efg.com")); assertTrue(ValidateUtils.validateEmail("abcd@efg.COM")); assertTrue(ValidateUtils.validateEmail("abc@EFG.co")); assertTrue(ValidateUtils.validateEmail("abc@efg.co.in")); assertTrue(ValidateUtils.validateEmail("abcd@efg.com")); assertTrue(ValidateUtils.validateEmail("abcd@efg.in")); assertTrue(ValidateUtils.validateEmail("abcd@efg.bhj")); assertTrue(ValidateUtils.validateEmail("abcd@ef56g.bhj")); assertTrue(ValidateUtils.validateEmail("abc+-%d@abc.com")); assertFalse(ValidateUtils.validateEmail("")); assertFalse(ValidateUtils.validateEmail("abcdefg.com")); assertFalse(ValidateUtils.validateEmail("abc@.com")); assertFalse(ValidateUtils.validateEmail("ab*-c@defg.com")); assertFalse(ValidateUtils.validateEmail("abcd")); assertFalse(ValidateUtils.validateEmail("abc@abc")); assertFalse(ValidateUtils.validateEmail("abc@@hjg.com")); assertFalse(ValidateUtils.validateEmail("abc@abc.co++-")); assertFalse(ValidateUtils.validateEmail("abc@ab/*c")); assertFalse(ValidateUtils.validateEmail("abc@ab/*c.com")); assertFalse(ValidateUtils.validateEmail("abcd@efg.co565m")); assertFalse(ValidateUtils.validateEmail("abcd@ghs.l")); assertFalse(ValidateUtils.validateEmail("abcd@efg.cojjjhjhjhjhjhjhjhm")); }

### Question: AuthRepository { @NonNull public FirebaseAuthLiveData getFirebaseAuthLiveData() { return firebaseAuthLiveData; } @Inject AuthRepository(FirebaseAuthLiveData firebaseAuthLiveData); @NonNull FirebaseAuthLiveData getFirebaseAuthLiveData(); }### Answer: @Test public void shouldReturnFireBaseLiveData() { FirebaseAuthLiveData expectedData = authRepository.getFirebaseAuthLiveData(); assertThat(expectedData, equalTo(firebaseAuthLiveData)); }

### Question: ProfileRepository { public void setUser(User user) { databaseReference.setValue(user); } @Inject ProfileRepository(DatabaseReference databaseReference, FirebaseAuth firebaseAuth); @NonNull LiveData<DataSnapshot> getUser(); void setUser(User user); void setField(UserFieldType userFieldType, String profileField); @VisibleForTesting public FirebaseDatabaseLiveData firebaseDatabaseLiveData; public DatabaseReference databaseReference; }### Answer: @Test public void shouldSetUser() { profileRepository.setUser(MOCK_USER); Mockito.verify(databaseReference).setValue(MOCK_USER); }

### Question: ProfileRepository { public void setField(UserFieldType userFieldType, String profileField) { databaseReference.child(userFieldType.key).setValue(profileField); } @Inject ProfileRepository(DatabaseReference databaseReference, FirebaseAuth firebaseAuth); @NonNull LiveData<DataSnapshot> getUser(); void setUser(User user); void setField(UserFieldType userFieldType, String profileField); @VisibleForTesting public FirebaseDatabaseLiveData firebaseDatabaseLiveData; public DatabaseReference databaseReference; }### Answer: @Test public void shouldSetField() { Mockito.when(databaseReference.child(UserFieldType.USERNAME.key)) .thenReturn(databaseReference); profileRepository.setField(UserFieldType.USERNAME, "test_username"); Mockito.verify(databaseReference).setValue("test_username"); }

### Question: ProfileRepository { @NonNull public LiveData<DataSnapshot> getUser() { return firebaseDatabaseLiveData; } @Inject ProfileRepository(DatabaseReference databaseReference, FirebaseAuth firebaseAuth); @NonNull LiveData<DataSnapshot> getUser(); void setUser(User user); void setField(UserFieldType userFieldType, String profileField); @VisibleForTesting public FirebaseDatabaseLiveData firebaseDatabaseLiveData; public DatabaseReference databaseReference; }### Answer: @Test public void shouldReturnUserLiveData() { LiveData<DataSnapshot> userLiveData = profileRepository.getUser(); Assert.assertSame(userLiveData, profileRepository.firebaseDatabaseLiveData); }

### Question: CodingCalendarViewModel extends ViewModel { protected LiveData<Resource<List<Contest>>> loadContests(boolean reload) { if (reload || repoListRateLimit.shouldFetch(CONTEST_VIEW_MODEL)) { contests = codingCalendarRepository.fetchContests(reload); repoListRateLimit.refreshRateLimiter(CONTEST_VIEW_MODEL); } return contests; } @Inject CodingCalendarViewModel(CodingCalendarRepository codingCalendarRepository, RateLimiter<String> repoListRateLimit); void openContestDetails(Long id); }### Answer: @Test public void shouldLoadContests_when_reloadFalse_and_rateLimitFalse() { Mockito.when(repoListRateLimit.shouldFetch(CodingCalendarViewModel.CONTEST_VIEW_MODEL)) .thenReturn(false); codingCalendarViewModel.loadContests(false); Mockito.verify(codingCalendarRepository, Mockito.never()).fetchContests(Mockito.anyBoolean()); Mockito.verify(repoListRateLimit, Mockito.never()).refreshRateLimiter(CodingCalendarViewModel.CONTEST_VIEW_MODEL); } @Test public void shouldLoadContests_when_reloadTrue_and_rateLimitFalse() { codingCalendarViewModel.loadContests(true); Mockito.verify(codingCalendarRepository).fetchContests(true); Mockito.verify(repoListRateLimit).refreshRateLimiter(CodingCalendarViewModel.CONTEST_VIEW_MODEL); } @Test public void shouldLoadContests_when_reloadFalse_and_rateLimitTrue() { Mockito.when(repoListRateLimit.shouldFetch(CodingCalendarViewModel.CONTEST_VIEW_MODEL)) .thenReturn(true); codingCalendarViewModel.loadContests(false); Mockito.verify(codingCalendarRepository).fetchContests(false); Mockito.verify(repoListRateLimit).refreshRateLimiter(CodingCalendarViewModel.CONTEST_VIEW_MODEL); }

### Question: MetricSampleAggregator extends LongGenerationed { public Long earliestWindow() { return _rawMetrics.isEmpty() ? null : _oldestWindowIndex * _windowMs; } MetricSampleAggregator(int numWindows, long windowMs, byte minSamplesPerWindow, int completenessCacheSize, MetricDef metricDef); boolean addSample(MetricSample<G, E> sample); MetricSampleAggregationResult<G, E> aggregate(long from, long to, AggregationOptions<G, E> options); Map<E, ValuesAndExtrapolations> peekCurrentWindow(); MetricSampleCompleteness<G, E> completeness(long from, long to, AggregationOptions<G, E> options); List<Long> availableWindows(); int numAvailableWindows(); int numAvailableWindows(long from, long to); List<Long> allWindows(); Long earliestWindow(); int numSamples(); void retainEntities(Set<E> entities); void removeEntities(Set<E> entities); void retainEntityGroup(Set<G> entityGroups); void removeEntityGroup(Set<G> entityGroups); void clear(); long monitoringPeriodMs(); }### Answer: @Test public void testEarliestWindow() { MetricSampleAggregator<String, IntegerEntity> aggregator = new MetricSampleAggregator<>(NUM_WINDOWS, WINDOW_MS, MIN_SAMPLES_PER_WINDOW, 0, _metricDef); assertNull(aggregator.earliestWindow()); CruiseControlUnitTestUtils.populateSampleAggregator(NUM_WINDOWS, MIN_SAMPLES_PER_WINDOW, aggregator, ENTITY1, 0, WINDOW_MS, _metricDef); assertEquals(WINDOW_MS, aggregator.earliestWindow().longValue()); CruiseControlUnitTestUtils.populateSampleAggregator(2, MIN_SAMPLES_PER_WINDOW, aggregator, ENTITY1, NUM_WINDOWS, WINDOW_MS, _metricDef); assertEquals(2 * WINDOW_MS, aggregator.earliestWindow().longValue()); }

### Question: AggregatedMetricValues { public void add(short metricId, MetricValues metricValuesToAdd) { if (metricValuesToAdd == null) { throw new IllegalArgumentException("The metric values to be added cannot be null"); } if (!_metricValues.isEmpty() && metricValuesToAdd.length() != length()) { throw new IllegalArgumentException("The existing metric length is " + length() + " which is different from the" + " metric length of " + metricValuesToAdd.length() + " that is being added."); } MetricValues metricValues = _metricValues.computeIfAbsent(metricId, id -> new MetricValues(metricValuesToAdd.length())); metricValues.add(metricValuesToAdd); } AggregatedMetricValues(); AggregatedMetricValues(Map<Short, MetricValues> valuesByMetricId); MetricValues valuesFor(short metricId); AggregatedMetricValues valuesFor(Collection<Short> metricIds, boolean shareValueArray); MetricValues valuesForGroup(String group, MetricDef metricDef, boolean shareValueArray); int length(); boolean isEmpty(); Set<Short> metricIds(); void add(short metricId, MetricValues metricValuesToAdd); void add(AggregatedMetricValues other); void subtract(AggregatedMetricValues other); void clear(); void writeTo(OutputStream out); @Override String toString(); }### Answer: @Test public void testAdd() { Map<Short, MetricValues> valuesByMetricId = getValuesByMetricId(); AggregatedMetricValues aggregatedMetricValues = new AggregatedMetricValues(valuesByMetricId); aggregatedMetricValues.add(aggregatedMetricValues); for (Map.Entry<Short, MetricValues> entry : valuesByMetricId.entrySet()) { MetricValues values = entry.getValue(); for (int j = 0; j < 10; j++) { assertEquals(2 * j, values.get(j), 0.01); } } }

### Question: AggregatedMetricValues { public void subtract(AggregatedMetricValues other) { for (Map.Entry<Short, MetricValues> entry : other.metricValues().entrySet()) { short metricId = entry.getKey(); MetricValues otherValuesForMetric = entry.getValue(); MetricValues valuesForMetric = valuesFor(metricId); if (valuesForMetric == null) { throw new IllegalStateException("Cannot subtract a values from a non-existing MetricValues"); } if (valuesForMetric.length() != otherValuesForMetric.length()) { throw new IllegalStateException("The two values arrays have different lengths " + valuesForMetric.length() + " and " + otherValuesForMetric.length()); } valuesForMetric.subtract(otherValuesForMetric); } } AggregatedMetricValues(); AggregatedMetricValues(Map<Short, MetricValues> valuesByMetricId); MetricValues valuesFor(short metricId); AggregatedMetricValues valuesFor(Collection<Short> metricIds, boolean shareValueArray); MetricValues valuesForGroup(String group, MetricDef metricDef, boolean shareValueArray); int length(); boolean isEmpty(); Set<Short> metricIds(); void add(short metricId, MetricValues metricValuesToAdd); void add(AggregatedMetricValues other); void subtract(AggregatedMetricValues other); void clear(); void writeTo(OutputStream out); @Override String toString(); }### Answer: @Test public void testDeduct() { Map<Short, MetricValues> valuesByMetricId = getValuesByMetricId(); AggregatedMetricValues aggregatedMetricValues = new AggregatedMetricValues(valuesByMetricId); aggregatedMetricValues.subtract(aggregatedMetricValues); for (Map.Entry<Short, MetricValues> entry : valuesByMetricId.entrySet()) { MetricValues values = entry.getValue(); for (int j = 0; j < 10; j++) { assertEquals(0, values.get(j), 0.01); } } }

### Question: ReplicationThrottleHelper { static String removeReplicasFromConfig(String throttleConfig, Set<String> replicas) { ArrayList<String> throttles = new ArrayList<>(Arrays.asList(throttleConfig.split(","))); throttles.removeIf(replicas::contains); return String.join(",", throttles); } ReplicationThrottleHelper(KafkaZkClient kafkaZkClient, Long throttleRate); }### Answer: @Test public void testRemoveReplicasFromConfigTest() { Set<String> replicas = new LinkedHashSet<>(); replicas.add("foo"); replicas.add("bar"); replicas.add("baz"); String throttleConfig = "foo,bar,qux,qaz,baz"; String result = ReplicationThrottleHelper.removeReplicasFromConfig(throttleConfig, replicas); assertEquals(result, "qux,qaz"); }

### Question: MetricSampleAggregator extends LongGenerationed { public List<Long> allWindows() { return getWindowList(_oldestWindowIndex, _currentWindowIndex); } MetricSampleAggregator(int numWindows, long windowMs, byte minSamplesPerWindow, int completenessCacheSize, MetricDef metricDef); boolean addSample(MetricSample<G, E> sample); MetricSampleAggregationResult<G, E> aggregate(long from, long to, AggregationOptions<G, E> options); Map<E, ValuesAndExtrapolations> peekCurrentWindow(); MetricSampleCompleteness<G, E> completeness(long from, long to, AggregationOptions<G, E> options); List<Long> availableWindows(); int numAvailableWindows(); int numAvailableWindows(long from, long to); List<Long> allWindows(); Long earliestWindow(); int numSamples(); void retainEntities(Set<E> entities); void removeEntities(Set<E> entities); void retainEntityGroup(Set<G> entityGroups); void removeEntityGroup(Set<G> entityGroups); void clear(); long monitoringPeriodMs(); }### Answer: @Test public void testAllWindows() { MetricSampleAggregator<String, IntegerEntity> aggregator = new MetricSampleAggregator<>(NUM_WINDOWS, WINDOW_MS, MIN_SAMPLES_PER_WINDOW, 0, _metricDef); assertTrue(aggregator.allWindows().isEmpty()); CruiseControlUnitTestUtils.populateSampleAggregator(NUM_WINDOWS + 1, MIN_SAMPLES_PER_WINDOW, aggregator, ENTITY1, 0, WINDOW_MS, _metricDef); List<Long> allStWindows = aggregator.allWindows(); assertEquals(NUM_WINDOWS + 1, allStWindows.size()); for (int i = 0; i < NUM_WINDOWS + 1; i++) { assertEquals((i + 1) * WINDOW_MS, allStWindows.get(i).longValue()); } }

### Question: ExecutionProposal { public Map<Integer, ReplicaPlacementInfo> replicasToMoveBetweenDisksByBroker() { return _replicasToMoveBetweenDisksByBroker; } ExecutionProposal(TopicPartition tp, long partitionSize, ReplicaPlacementInfo oldLeader, List<ReplicaPlacementInfo> oldReplicas, List<ReplicaPlacementInfo> newReplicas); boolean isInterBrokerMovementCompleted(PartitionInfo partitionInfo); boolean isInterBrokerMovementAborted(PartitionInfo partitionInfo); String topic(); int partitionId(); TopicPartition topicPartition(); ReplicaPlacementInfo oldLeader(); ReplicaPlacementInfo newLeader(); List<ReplicaPlacementInfo> oldReplicas(); List<ReplicaPlacementInfo> newReplicas(); Set<ReplicaPlacementInfo> replicasToAdd(); Set<ReplicaPlacementInfo> replicasToRemove(); Map<Integer, ReplicaPlacementInfo> replicasToMoveBetweenDisksByBroker(); boolean hasReplicaAction(); boolean hasLeaderAction(); long interBrokerDataToMoveInMB(); long intraBrokerDataToMoveInMB(); long dataToMoveInMB(); Map<String, Object> getJsonStructure(); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); }### Answer: @Test public void testIntraBrokerReplicaMovements() { ExecutionProposal p = new ExecutionProposal(TP, 0, _r0d0, Arrays.asList(_r0d0, _r1d1), Arrays.asList(_r0d1, _r1d1)); Assert.assertEquals(1, p.replicasToMoveBetweenDisksByBroker().size()); }

### Question: OperationProgress { public void refer(OperationProgress other) { List<OperationStep> steps; List<Long> startTimes; synchronized (other) { steps = other._steps; startTimes = other._startTimes; } synchronized (this) { ensureMutable(); this._steps = steps; this._startTimes = startTimes; this._mutable = false; } } OperationProgress(); OperationProgress(String operation); synchronized void addStep(OperationStep step); void refer(OperationProgress other); synchronized List<OperationStep> progress(); synchronized void clear(); @Override synchronized String toString(); Map<String, Object> getJsonStructure(); }### Answer: @Test public void testRefer() { OperationProgress progress1 = new OperationProgress(); progress1.addStep(new Pending()); OperationProgress progress2 = new OperationProgress(); progress2.addStep(new WaitingForClusterModel()); assertTrue(progress1.progress().get(0) instanceof Pending); progress1.refer(progress2); assertTrue(progress1.progress().get(0) instanceof WaitingForClusterModel); assertEquals(progress1.progress(), progress2.progress()); }

### Question: JwtAuthenticator extends LoginAuthenticator { String getJwtFromBearerAuthorization(HttpServletRequest req) { String authorizationHeader = req.getHeader(HttpHeader.AUTHORIZATION.asString()); if (authorizationHeader == null || !authorizationHeader.startsWith(BEARER)) { return null; } else { return authorizationHeader.substring(BEARER.length()).trim(); } } JwtAuthenticator(String authenticationProviderUrl, String cookieName); @Override String getAuthMethod(); @Override void prepareRequest(ServletRequest request); @Override Authentication validateRequest(ServletRequest request, ServletResponse response, boolean mandatory); @Override boolean secureResponse(ServletRequest request, ServletResponse response, boolean mandatory, Authentication.User validatedUser); static final String JWT_TOKEN_REQUEST_ATTRIBUTE; }### Answer: @Test public void testParseTokenFromAuthHeader() { JwtAuthenticator authenticator = new JwtAuthenticator(TOKEN_PROVIDER, JWT_TOKEN); HttpServletRequest request = mock(HttpServletRequest.class); expect(request.getHeader(HttpHeader.AUTHORIZATION.asString())).andReturn(JwtAuthenticator.BEARER + " " + EXPECTED_TOKEN); replay(request); String actualToken = authenticator.getJwtFromBearerAuthorization(request); verify(request); assertEquals(EXPECTED_TOKEN, actualToken); } @Test public void testParseTokenFromAuthHeaderNoBearer() { JwtAuthenticator authenticator = new JwtAuthenticator(TOKEN_PROVIDER, JWT_TOKEN); HttpServletRequest request = mock(HttpServletRequest.class); expect(request.getHeader(HttpHeader.AUTHORIZATION.asString())).andReturn(BASIC_SCHEME + " " + EXPECTED_TOKEN); replay(request); String actualToken = authenticator.getJwtFromBearerAuthorization(request); verify(request); assertNull(actualToken); }

### Question: JwtAuthenticator extends LoginAuthenticator { String getJwtFromCookie(HttpServletRequest req) { String serializedJWT = null; Cookie[] cookies = req.getCookies(); if (cookies != null) { for (Cookie cookie : cookies) { if (_cookieName != null && _cookieName.equals(cookie.getName())) { JWT_LOGGER.trace(_cookieName + " cookie has been found and is being processed"); serializedJWT = cookie.getValue(); break; } } } return serializedJWT; } JwtAuthenticator(String authenticationProviderUrl, String cookieName); @Override String getAuthMethod(); @Override void prepareRequest(ServletRequest request); @Override Authentication validateRequest(ServletRequest request, ServletResponse response, boolean mandatory); @Override boolean secureResponse(ServletRequest request, ServletResponse response, boolean mandatory, Authentication.User validatedUser); static final String JWT_TOKEN_REQUEST_ATTRIBUTE; }### Answer: @Test public void testParseTokenFromCookie() { JwtAuthenticator authenticator = new JwtAuthenticator(TOKEN_PROVIDER, JWT_TOKEN); HttpServletRequest request = mock(HttpServletRequest.class); expect(request.getCookies()).andReturn(new Cookie[] {new Cookie(JWT_TOKEN, EXPECTED_TOKEN)}); replay(request); String actualToken = authenticator.getJwtFromCookie(request); verify(request); assertEquals(EXPECTED_TOKEN, actualToken); } @Test public void testParseTokenFromCookieNoJwtCookie() { JwtAuthenticator authenticator = new JwtAuthenticator(TOKEN_PROVIDER, JWT_TOKEN); HttpServletRequest request = mock(HttpServletRequest.class); expect(request.getCookies()).andReturn(new Cookie[] {new Cookie(RANDOM_COOKIE_NAME, "")}); replay(request); String actualToken = authenticator.getJwtFromCookie(request); verify(request); assertNull(actualToken); }

### Question: SpnegoUserStoreAuthorizationService extends UserStoreAuthorizationService { @Override public UserIdentity getUserIdentity(HttpServletRequest request, String name) { int hostSeparator = name.indexOf('/'); String shortName = hostSeparator > 0 ? name.substring(0, hostSeparator) : name; int realmSeparator = shortName.indexOf('@'); shortName = realmSeparator > 0 ? shortName.substring(0, realmSeparator) : shortName; return super.getUserIdentity(request, shortName); } SpnegoUserStoreAuthorizationService(String privilegesFilePath); SpnegoUserStoreAuthorizationService(UserStore userStore); @Override UserIdentity getUserIdentity(HttpServletRequest request, String name); }### Answer: @Test public void testPrincipalNames() { UserStore users = new UserStore(); users.addUser(TEST_USER, SecurityUtils.NO_CREDENTIAL, new String[] { DefaultRoleSecurityProvider.ADMIN }); UserStoreAuthorizationService usas = new SpnegoUserStoreAuthorizationService(users); UserIdentity result = usas.getUserIdentity(null, TEST_USER + "/host@REALM"); assertNotNull(result); assertEquals(TEST_USER, result.getUserPrincipal().getName()); result = usas.getUserIdentity(null, TEST_USER + "@REALM"); assertNotNull(result); assertEquals(TEST_USER, result.getUserPrincipal().getName()); result = usas.getUserIdentity(null, TEST_USER + "/host"); assertNotNull(result); assertEquals(TEST_USER, result.getUserPrincipal().getName()); result = usas.getUserIdentity(null, TEST_USER); assertNotNull(result); assertEquals(TEST_USER, result.getUserPrincipal().getName()); }

### Question: OperationFuture extends CompletableFuture<CruiseControlResponse> { public synchronized boolean setExecutionThread(Thread t) { if (isCancelled() && t != null) { return false; } else { _executionThread = t; return true; } } OperationFuture(String operation); @Override synchronized boolean cancel(boolean mayInterruptIfRunning); @Override CruiseControlResponse get(); String operation(); synchronized boolean setExecutionThread(Thread t); String progressString(); Map<String, Object> getJsonStructure(); OperationProgress operationProgress(); void setFinishTimeNs(long finishTimeNs); long finishTimeNs(); }### Answer: @Test public void testSetExecutionThread() { OperationFuture future = new OperationFuture("testSetExecutionThread"); assertTrue(future.setExecutionThread(new Thread())); future.cancel(true); assertTrue("Should be able to set the execution thread of canceled future to null", future.setExecutionThread(null)); assertFalse("Should failed to set execution thread for the canceled future.", future.setExecutionThread(new Thread())); }

### Question: BrokerFailures extends KafkaAnomaly { @Override public String toString() { StringBuilder sb = new StringBuilder().append("{"); sb.append(_fixable ? "Fixable " : " Unfixable "); sb.append("broker failures detected: {"); if (_failedBrokers != null) { _failedBrokers.forEach((key, value) -> { sb.append("Broker ").append(key).append(" failed at ").append(toDateString(value)).append(",\t"); }); sb.setLength(sb.length() - 2); } sb.append("}}"); return sb.toString(); } BrokerFailures(); Map<Integer, Long> failedBrokers(); boolean fixable(); @Override boolean fix(); @Override AnomalyType anomalyType(); @Override Supplier<String> reasonSupplier(); @Override String toString(); @SuppressWarnings("unchecked") @Override void configure(Map<String, ?> configs); }### Answer: @Test public void testToString() { assertNotNull(new BrokerFailures().toString()); }

### Question: SlackMessage implements Serializable { @Override public String toString() { return "{\"username\" : " + (_username == null ? null : "\"" + _username + "\"") + ",\"text\" : " + (_text == null ? null : "\"" + _text + "\"") + ",\"icon_emoji\" : " + (_iconEmoji == null ? null : "\"" + _iconEmoji + "\"") + ",\"channel\" : " + (_channel == null ? null : "\"" + _channel + "\"") + "}"; } SlackMessage(String username, String text, String iconEmoji, String channel); String getUsername(); String getText(); String getIconEmoji(); String getChannel(); @Override String toString(); }### Answer: @Test public void testSlackMessageJsonFormat() { String expectedJson = "{\"username\" : \"userA\",\"text\" : \"cc alert\",\"icon_emoji\" : \":information_source:" + "\",\"channel\" : \"#cc-alerts\"}"; assertEquals(expectedJson, new SlackMessage("userA", "cc alert", ":information_source:", "#cc-alerts").toString()); }

### Question: MaintenanceEvent extends KafkaAnomaly { @Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append(String.format("{Handling %s", _maintenanceEventType)); if (_topicsWithRFUpdate != null) { sb.append(String.format(" by desired RF: [%s]", _topicsWithRFUpdate)); } else if (_brokers != null) { sb.append(String.format(" for brokers: [%s]", _brokers)); } sb.append("}"); return sb.toString(); } @Override Supplier<String> reasonSupplier(); @Override AnomalyType anomalyType(); MaintenanceEventType maintenanceEventType(); @Override boolean fix(); @Override String toString(); @Override void configure(Map<String, ?> configs); static final String MAINTENANCE_EVENT_TYPE_CONFIG; static final String BROKERS_OBJECT_CONFIG; static final String TOPICS_WITH_RF_UPDATE_CONFIG; }### Answer: @Test public void testToStringBeforeConfiguration() { assertNotNull(new MaintenanceEvent().toString()); }

### Question: AnomalyUtils { public static Pattern buildTopicRegex(Set<String> stringsToMatch) { StringJoiner sj = new StringJoiner("|"); stringsToMatch.forEach(sj::add); return Pattern.compile(sj.toString()); } private AnomalyUtils(); static KafkaCruiseControl extractKafkaCruiseControlObjectFromConfig(Map<String, ?> configs, AnomalyType anomalyType); static boolean isLoadMonitorReady(LoadMonitorTaskRunner.LoadMonitorTaskRunnerState loadMonitorTaskRunnerState); static Pattern buildTopicRegex(Set<String> stringsToMatch); static int parseAndGetConfig(Map<String, Object> config, String key, int defaultValue, Predicate<Integer> illegalValueCheck); static double parseAndGetConfig(Map<String, Object> config, String key, double defaultValue, Predicate<Double> illegalValueCheck); }### Answer: @Test public void testBuildTopicRegex() { Set<String> topicsToMatch = new HashSet<>(2); topicsToMatch.add(TOPIC1); topicsToMatch.add(TOPIC2); Pattern pattern = buildTopicRegex(topicsToMatch); assertTrue(pattern.matcher(TOPIC1).matches()); assertTrue(pattern.matcher(TOPIC2).matches()); assertFalse(pattern.matcher(TOPIC3).matches()); }