Datasets:

Minata
/

1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 269k rows

method2testcases stringlengths 118 6.63k
### Question: PoolManagement { public RedisPools createRedisPoolAndConnection(RedisPoolProperty property) throws Exception { return getRedisPool(createRedisPool(property)); } private PoolManagement(); synchronized static PoolManagement getInstance(); RedisPools getRedisPool(); RedisPools getRedisPool(String poolId); RedisPools createRedisPoolAndConnection(RedisPoolProperty property); String createRedisPool(RedisPoolProperty property); boolean checkConnection(RedisPoolProperty property); boolean switchPool(String PoolId); String deleteRedisPool(String poolId); boolean clearAllPools(); boolean destroyRedisPool(String poolId); boolean destroyRedisPool(RedisPools redisPools); ConcurrentMap<String, RedisPools> getPoolMap(); }### Answer: @Test public void testCreateRedisPoolAndConnection() throws Exception { RedisPools result = poolManagement.createRedisPoolAndConnection(property); Jedis jedis = result.getJedis(); jedis.set("names","testCreateRedisPoolAndConnection"); Assert.assertEquals("testCreateRedisPoolAndConnection",jedis.get("names")); jedis.del("names"); }
### Question: RedisHash extends Commands { public Long saveWhenNotExist(String key, String member, String value) { return getJedis().hsetnx(key, member, value); } private RedisHash(); synchronized static RedisHash getInstance(); Long save(String key, String member, String value); String save(String key, Map<String, String> map); Long saveWhenNotExist(String key, String member, String value); String get(String key, String member); List<String> get(String key, String... member); Set<String> getMembers(String key); List<String> getValues(String key); Map<String, String> getAllMap(String key); Long increase(String key, String member, long value); Double increaseByFloat(String key, String member, double value); Long length(String key); Long remove(String key, String... members); }### Answer: @Test public void testSaveWhenNotExist() throws Exception { redisHash.save(key,"member","value"); Long result = redisHash.saveWhenNotExist(key, "member", "value2"); show(); Assert.assertEquals((Long)0L, result); }
### Question: RedisHash extends Commands { public String get(String key, String member) { return getJedis().hget(key, member); } private RedisHash(); synchronized static RedisHash getInstance(); Long save(String key, String member, String value); String save(String key, Map<String, String> map); Long saveWhenNotExist(String key, String member, String value); String get(String key, String member); List<String> get(String key, String... member); Set<String> getMembers(String key); List<String> getValues(String key); Map<String, String> getAllMap(String key); Long increase(String key, String member, long value); Double increaseByFloat(String key, String member, double value); Long length(String key); Long remove(String key, String... members); }### Answer: @Test public void testGet() throws Exception { redisHash.save(key,"member","value"); String result = redisHash.get(key, "member"); show(); Assert.assertEquals("value", result); }
### Question: RedisHash extends Commands { public Set<String> getMembers(String key) { return getJedis().hkeys(key); } private RedisHash(); synchronized static RedisHash getInstance(); Long save(String key, String member, String value); String save(String key, Map<String, String> map); Long saveWhenNotExist(String key, String member, String value); String get(String key, String member); List<String> get(String key, String... member); Set<String> getMembers(String key); List<String> getValues(String key); Map<String, String> getAllMap(String key); Long increase(String key, String member, long value); Double increaseByFloat(String key, String member, double value); Long length(String key); Long remove(String key, String... members); }### Answer: @Test public void testGetMembers() throws Exception { redisHash.save(key,"member","value"); redisHash.save(key,"member2","value"); Set<String> result = redisHash.getMembers(key); show(); Assert.assertEquals(new HashSet(Arrays.asList("member","member2")), result); }
### Question: RedisHash extends Commands { public List<String> getValues(String key) { return getJedis().hvals(key); } private RedisHash(); synchronized static RedisHash getInstance(); Long save(String key, String member, String value); String save(String key, Map<String, String> map); Long saveWhenNotExist(String key, String member, String value); String get(String key, String member); List<String> get(String key, String... member); Set<String> getMembers(String key); List<String> getValues(String key); Map<String, String> getAllMap(String key); Long increase(String key, String member, long value); Double increaseByFloat(String key, String member, double value); Long length(String key); Long remove(String key, String... members); }### Answer: @Test public void testGetValues() throws Exception { redisHash.save(key,"member","value"); redisHash.save(key,"member2","value"); List<String> result = redisHash.getValues(key); show(); Assert.assertEquals(Arrays.asList("value","value"), result); }
### Question: RedisHash extends Commands { public Long increase(String key, String member, long value) throws TypeErrorException { Long result; try { result = getJedis().hincrBy(key, member, value); } catch (Exception e) { throw new TypeErrorException(ExceptionInfo.TYPE_ERROR, e, RedisHash.class); } return result; } private RedisHash(); synchronized static RedisHash getInstance(); Long save(String key, String member, String value); String save(String key, Map<String, String> map); Long saveWhenNotExist(String key, String member, String value); String get(String key, String member); List<String> get(String key, String... member); Set<String> getMembers(String key); List<String> getValues(String key); Map<String, String> getAllMap(String key); Long increase(String key, String member, long value); Double increaseByFloat(String key, String member, double value); Long length(String key); Long remove(String key, String... members); }### Answer: @Test public void testIncrease() throws Exception { redisHash.save(key,"member","34"); Long result = redisHash.increase(key, "member", 56L); show(); Assert.assertEquals((Long)90L, result); }
### Question: RedisHash extends Commands { public Double increaseByFloat(String key, String member, double value) throws TypeErrorException { Double result; try { result = getJedis().hincrByFloat(key, member, value); } catch (Exception e) { throw new TypeErrorException(ExceptionInfo.TYPE_ERROR, e, RedisHash.class); } return result; } private RedisHash(); synchronized static RedisHash getInstance(); Long save(String key, String member, String value); String save(String key, Map<String, String> map); Long saveWhenNotExist(String key, String member, String value); String get(String key, String member); List<String> get(String key, String... member); Set<String> getMembers(String key); List<String> getValues(String key); Map<String, String> getAllMap(String key); Long increase(String key, String member, long value); Double increaseByFloat(String key, String member, double value); Long length(String key); Long remove(String key, String... members); }### Answer: @Test public void testIncreaseByFloat() throws Exception { redisHash.save(key,"member","1"); Double result = redisHash.increaseByFloat(key, "member", 22d); Assert.assertEquals((Double) 23.0, result); }
### Question: RedisHash extends Commands { public Long length(String key) { return getJedis().hlen(key); } private RedisHash(); synchronized static RedisHash getInstance(); Long save(String key, String member, String value); String save(String key, Map<String, String> map); Long saveWhenNotExist(String key, String member, String value); String get(String key, String member); List<String> get(String key, String... member); Set<String> getMembers(String key); List<String> getValues(String key); Map<String, String> getAllMap(String key); Long increase(String key, String member, long value); Double increaseByFloat(String key, String member, double value); Long length(String key); Long remove(String key, String... members); }### Answer: @Test public void testLength() throws Exception { redisHash.save(key,"member","23.2"); redisHash.save(key,"member1","23.2"); redisHash.save(key,"member2","23.2"); Long result = redisHash.length(key); show(); Assert.assertEquals((Long)3L, result); }
### Question: RedisHash extends Commands { public Long remove(String key, String... members) { return getJedis().hdel(key, members); } private RedisHash(); synchronized static RedisHash getInstance(); Long save(String key, String member, String value); String save(String key, Map<String, String> map); Long saveWhenNotExist(String key, String member, String value); String get(String key, String member); List<String> get(String key, String... member); Set<String> getMembers(String key); List<String> getValues(String key); Map<String, String> getAllMap(String key); Long increase(String key, String member, long value); Double increaseByFloat(String key, String member, double value); Long length(String key); Long remove(String key, String... members); }### Answer: @Test public void testRemove() throws Exception { redisHash.save(key,"member","23.2"); Long result = redisHash.remove(key, "member"); show(); Assert.assertEquals((Long)1L, result); }
### Question: PoolManagement { public RedisPools getRedisPool() { if (currentPoolId == null) { logger.error(ExceptionInfo.NOT_EXIST_CURRENT_POOL); return null; } try { return getRedisPool(currentPoolId); } catch (Exception e) { logger.error(e.getMessage()); logger.debug(NoticeInfo.ERROR_INFO, e); return null; } } private PoolManagement(); synchronized static PoolManagement getInstance(); RedisPools getRedisPool(); RedisPools getRedisPool(String poolId); RedisPools createRedisPoolAndConnection(RedisPoolProperty property); String createRedisPool(RedisPoolProperty property); boolean checkConnection(RedisPoolProperty property); boolean switchPool(String PoolId); String deleteRedisPool(String poolId); boolean clearAllPools(); boolean destroyRedisPool(String poolId); boolean destroyRedisPool(RedisPools redisPools); ConcurrentMap<String, RedisPools> getPoolMap(); }### Answer: @Test public void testGetRedisPool() throws Exception { RedisPools result = poolManagement.getRedisPool(); System.out.println(result.getDatabaseNum()); Jedis jedis = result.getJedis(); jedis.keys(""); jedis.set("names","testGetRedisPool"); Assert.assertEquals("testGetRedisPool",jedis.get("names")); }
### Question: PoolManagement { public boolean checkConnection(RedisPoolProperty property) { if (!validate(property)) { return false; } RedisPools pools = new RedisPools(); pools.setProperty(property); boolean flag = pools.available(); pools.destroyPool(); return flag; } private PoolManagement(); synchronized static PoolManagement getInstance(); RedisPools getRedisPool(); RedisPools getRedisPool(String poolId); RedisPools createRedisPoolAndConnection(RedisPoolProperty property); String createRedisPool(RedisPoolProperty property); boolean checkConnection(RedisPoolProperty property); boolean switchPool(String PoolId); String deleteRedisPool(String poolId); boolean clearAllPools(); boolean destroyRedisPool(String poolId); boolean destroyRedisPool(RedisPools redisPools); ConcurrentMap<String, RedisPools> getPoolMap(); }### Answer: @Test public void testCheckConnection(){ property = new RedisPoolProperty(); property.setHost("120.25.203.47"); property.setMaxActive(400); property.setMaxIdle(100); property.setMaxWaitMills(10000); property.setTestOnBorrow(false); property.setName("myth"); property.setPort(6381); property.setPassword("myth"); property.setTimeout(600); boolean result = poolManagement.checkConnection(property); System.out.println(result); Assert.assertEquals(true, result); }
### Question: SplashUrlDecoder { public static LaunchData getLaunchType(String launchUri) { if (launchUri == null) { launchUri = ""; } LaunchData data; if (launchUri.contains(ADD_ISSUER_PATH)) { data = handleAddIssuerUri(launchUri); if (data != null) { return data; } } else if (launchUri.contains(ADD_CERT_PATH)) { data = handleAddCertificateUri(launchUri); if (data != null) { return data; } } return new LaunchData(LaunchType.ONBOARDING); } static LaunchData getLaunchType(String launchUri); }### Answer: @Test public void emptyLaunchUrlLaunchesOnboarding() { LaunchData launchData = SplashUrlDecoder.getLaunchType(""); assertEquals(ONBOARDING, launchData.getLaunchType()); } @Test public void blockcertsDirectAddCertificateUrlLaunchesCertificateFlow() { LaunchData launchData = SplashUrlDecoder.getLaunchType(BLOCKCERTS_DIRECT_ADD_CERTIFICATE_URL); assertEquals(ADD_CERTIFICATE, launchData.getLaunchType()); assertEquals("https: } @Test public void nullLaunchUrlLaunchesOnboarding() { LaunchData launchData = SplashUrlDecoder.getLaunchType(null); assertEquals(ONBOARDING, launchData.getLaunchType()); } @Test public void issuerUrlLaunchesIssuerFlow() { LaunchData launchData = SplashUrlDecoder.getLaunchType(ADD_ISSUER_URL); assertEquals(ADD_ISSUER, launchData.getLaunchType()); assertEquals("https: assertEquals("abcd", launchData.getNonce()); } @Test public void shortIssuerUrlLaunchesDefault() { LaunchData launchData = SplashUrlDecoder.getLaunchType("https: assertEquals(ONBOARDING, launchData.getLaunchType()); } @Test public void longIssuerUrlLaunchesIssuerFlow() { LaunchData launchData = SplashUrlDecoder.getLaunchType(ADD_ISSUER_URL + "/extra"); assertEquals(ADD_ISSUER, launchData.getLaunchType()); assertEquals("https: assertEquals("abcd", launchData.getNonce()); } @Test public void certificateUrlLaunchesCertificateFlow() { LaunchData launchData = SplashUrlDecoder.getLaunchType(ADD_CERTIFICATE_URL); assertEquals(ADD_CERTIFICATE, launchData.getLaunchType()); assertEquals("https: } @Test public void shortCertificateUrlLaunchesDefault() { LaunchData launchData = SplashUrlDecoder.getLaunchType("https: assertEquals(ONBOARDING, launchData.getLaunchType()); } @Test public void blockcertsAddIssuerUrlLaunchesIssuerFlow() { LaunchData launchData = SplashUrlDecoder.getLaunchType(BLOCKCERTS_ADD_ISSUER_URL); assertEquals(ADD_ISSUER, launchData.getLaunchType()); assertEquals("https: assertEquals("abcd", launchData.getNonce()); } @Test public void blockcertsCertificateUrlLaunchesCertificateFlow() { LaunchData launchData = SplashUrlDecoder.getLaunchType(BLOCKCERTS_ADD_CERTIFICATE_URL); assertEquals(ADD_CERTIFICATE, launchData.getLaunchType()); assertEquals("https: } @Test public void blockcertsDirectAddIssuerUrlLaunchesIssuerFlow() { LaunchData launchData = SplashUrlDecoder.getLaunchType(BLOCKCERTS_DIRECT_ADD_ISSUER_URL); assertEquals(ADD_ISSUER, launchData.getLaunchType()); assertEquals("https: assertEquals("abcd", launchData.getNonce()); }
### Question: Metadata { public List<String> getDisplayOrder() { return mDisplayOrder; } Metadata(List<String> displayOrder, Map<String, JsonObject> groups, Map<String, GroupDef> groupDefinitions, List<Field> fields); List<String> getDisplayOrder(); Map<String, JsonObject> getGroups(); Map<String, GroupDef> getGroupDefinitions(); List<Field> getFields(); }### Answer: @Test public void hasCorrectDisplayOrder() { assertEquals(7, subject.getDisplayOrder().size()); assertEquals("group.date", subject.getDisplayOrder().get(1)); }
### Question: Metadata { public List<Field> getFields() { return mFields; } Metadata(List<String> displayOrder, Map<String, JsonObject> groups, Map<String, GroupDef> groupDefinitions, List<Field> fields); List<String> getDisplayOrder(); Map<String, JsonObject> getGroups(); Map<String, GroupDef> getGroupDefinitions(); List<Field> getFields(); }### Answer: @Test public void hasCorrectStringField() { Field field = subject.getFields().get(0); assertEquals("Text title", field.getTitle()); assertEquals("string", field.getValue()); } @Test public void hasCorrectNumberField() { Field field = subject.getFields().get(4); assertEquals("GPA", field.getTitle()); assertEquals("3.7", field.getValue()); } @Test public void hasCorrectBooleanField() { Field field = subject.getFields().get(6); assertEquals("is this a boolean?", field.getTitle()); assertEquals("True", field.getValue()); }
### Question: BitcoinUtils { public static List<String> generateMnemonic(byte[] seedData) { if (MnemonicCode.INSTANCE == null) { return null; } try { return MnemonicCode.INSTANCE.toMnemonic(seedData); } catch (MnemonicException.MnemonicLengthException e) { Timber.e(e, "Unable to create mnemonic from word list"); } return null; } static void init(Context context); static List<String> generateMnemonic(byte[] seedData); static Wallet createWallet(NetworkParameters params, String seedPhrase); @NonNull static Wallet createWallet(NetworkParameters params, byte[] entropy); static Wallet loadWallet(InputStream walletStream, NetworkParameters networkParameters); static boolean updateRequired(Wallet wallet); static Wallet updateWallet(Wallet wallet); static boolean isValidPassphrase(String passphrase); }### Answer: @Test public void testGenerateMnemonic() throws Exception { byte[] seedData = new byte[32]; String expectedMnemonic = ABANDON_ABANDON_ART; List<String> seedPhrase = BitcoinUtils.generateMnemonic(seedData); assertFalse(ListUtils.isEmpty(seedPhrase)); String mnemonic = StringUtils.join(" ", seedPhrase); assertFalse("Mnemonic phrase should not be empty", mnemonic.isEmpty()); assertEquals("0-seed should generate simple mnemonic phrase", expectedMnemonic, mnemonic); }
### Question: BitcoinUtils { public static boolean isValidPassphrase(String passphrase) { try { byte[] entropy = MnemonicCode.INSTANCE.toEntropy(Arrays.asList(passphrase.split(" "))); return entropy.length > 0; } catch (MnemonicException e) { Timber.e(e, "Invalid passphrase"); return false; } } static void init(Context context); static List<String> generateMnemonic(byte[] seedData); static Wallet createWallet(NetworkParameters params, String seedPhrase); @NonNull static Wallet createWallet(NetworkParameters params, byte[] entropy); static Wallet loadWallet(InputStream walletStream, NetworkParameters networkParameters); static boolean updateRequired(Wallet wallet); static Wallet updateWallet(Wallet wallet); static boolean isValidPassphrase(String passphrase); }### Answer: @Test public void detectsValidPassphrases() { String seedPhrase = ABANDON_ABANDON_ART; assertTrue("This should be a valid phrase", BitcoinUtils.isValidPassphrase(seedPhrase)); } @Test public void detectsInvalidPassphrases() { String seedPhrase = "This phrase is too short and not random enough"; assertFalse("This should be an invalid phrase", BitcoinUtils.isValidPassphrase(seedPhrase)); }
### Question: Cloud { public void createPacketsFile() { File packetsFile = new File(this.sharedDir, "Packets.txt"); if (packetsFile.exists()) { try { packetsFile.createNewFile(); } catch (IOException e) { log.error("Cannot create", e); } } try (PrintWriter writer = new PrintWriter(new FileOutputStream(packetsFile))) { for (Class<? extends Packet> packet : PacketManager.getInstance().getPackets()) writer.println(packet.getSimpleName()); } catch (FileNotFoundException e) { log.error("file not found", e); } } Cloud(); void stop(); void createPacketsFile(); static Logger getLogger(); static void main(String... args); }### Answer: @Test public void testPacketsCreationFile() { Cloud cloud = new Cloud(); cloud.createPacketsFile(); File file = new File(cloud.getSharedDir(), "Packets.txt"); try (BufferedReader inputStream = new BufferedReader(new FileReader(file))) { List<String> lines = inputStream.lines().collect(Collectors.toList()); for (int i = 0; i < lines.size(); i++) { assertEquals(PacketManager.getInstance().getPackets().get(i).getSimpleName(), lines.get(i)); } } catch (IOException e) { e.printStackTrace(); } }
### Question: QuestionRepository implements QuestionDataSource { @Override public Flowable<List<Question>> loadQuestions(boolean forceRemote) { if (forceRemote) { return refreshData(); } else { if (caches.size() > 0) { return Flowable.just(caches); } else { return localDataSource.loadQuestions(false) .take(1) .flatMap(Flowable::fromIterable) .doOnNext(question -> caches.add(question)) .toList() .toFlowable() .filter(list -> !list.isEmpty()) .switchIfEmpty( refreshData()); } } } @Inject QuestionRepository(@Local QuestionDataSource localDataSource, @Remote QuestionDataSource remoteDataSource); @Override Flowable<List<Question>> loadQuestions(boolean forceRemote); Flowable<Question> getQuestion(long questionId); @Override void addQuestion(Question question); @Override void clearData(); }### Answer: @Test public void loadQuestions_ShouldReturnCache_IfItIsAvailable() { repository.caches.addAll(questions); repository.loadQuestions(false).subscribe(questionsTestSubscriber); verifyZeroInteractions(localDataSource); verifyZeroInteractions(remoteDataSource); questionsTestSubscriber.assertValue(questions); } @Test public void loadQuestions_ShouldReturnFromLocal_IfCacheIsNotAvailable() { doReturn(Flowable.just(questions)).when(localDataSource).loadQuestions(false); doReturn(Flowable.just(questions)).when(remoteDataSource).loadQuestions(true); repository.loadQuestions(false).subscribe(questionsTestSubscriber); verify(localDataSource).loadQuestions(false); verify(remoteDataSource).loadQuestions(true); questionsTestSubscriber.assertValue(questions); }
### Question: QuestionRemoteDataSource implements QuestionDataSource { @Override public void clearData() { throw new UnsupportedOperationException("Unsupported operation"); } @Inject QuestionRemoteDataSource(QuestionService questionService); @Override Flowable<List<Question>> loadQuestions(boolean forceRemote); @Override void addQuestion(Question question); @Override void clearData(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void clearData_NoThingToDoWithRemoteService() { remoteDataSource.clearData(); then(questionService).shouldHaveZeroInteractions(); }
### Question: QuestionRepository implements QuestionDataSource { public Flowable<Question> getQuestion(long questionId) { return Flowable.fromIterable(caches).filter(question -> question.getId() == questionId); } @Inject QuestionRepository(@Local QuestionDataSource localDataSource, @Remote QuestionDataSource remoteDataSource); @Override Flowable<List<Question>> loadQuestions(boolean forceRemote); Flowable<Question> getQuestion(long questionId); @Override void addQuestion(Question question); @Override void clearData(); }### Answer: @Test public void getQuestion_ShouldReturnFromCache() { question1.setId(1); question2.setId(2); question3.setId(3); repository.caches.addAll(questions); TestSubscriber<Question> subscriber = new TestSubscriber<>(); repository.getQuestion(1).subscribe(subscriber); then(localDataSource).shouldHaveZeroInteractions(); then(remoteDataSource).shouldHaveZeroInteractions(); subscriber.assertValue(question1); }
### Question: QuestionRepository implements QuestionDataSource { @Override public void clearData() { caches.clear(); localDataSource.clearData(); } @Inject QuestionRepository(@Local QuestionDataSource localDataSource, @Remote QuestionDataSource remoteDataSource); @Override Flowable<List<Question>> loadQuestions(boolean forceRemote); Flowable<Question> getQuestion(long questionId); @Override void addQuestion(Question question); @Override void clearData(); }### Answer: @Test public void clearData_ShouldClearCachesAndLocalData() { repository.caches.addAll(questions); repository.clearData(); assertThat(repository.caches, empty()); then(localDataSource).should().clearData(); }
### Question: QuestionRepository implements QuestionDataSource { @Override public void addQuestion(Question question) { throw new UnsupportedOperationException("Unsupported operation"); } @Inject QuestionRepository(@Local QuestionDataSource localDataSource, @Remote QuestionDataSource remoteDataSource); @Override Flowable<List<Question>> loadQuestions(boolean forceRemote); Flowable<Question> getQuestion(long questionId); @Override void addQuestion(Question question); @Override void clearData(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void addQuestion_ShouldThrowException() { repository.addQuestion(question1); }
### Question: QuestionLocalDataSource implements QuestionDataSource { @Override public Flowable<List<Question>> loadQuestions(boolean forceRemote) { return questionDao.getAllQuestions(); } @Inject QuestionLocalDataSource(QuestionDao questionDao); @Override Flowable<List<Question>> loadQuestions(boolean forceRemote); @Override void addQuestion(Question question); @Override void clearData(); }### Answer: @Test public void loadQuestions_ShouldReturnFromDatabase() { List<Question> questions = Arrays.asList(new Question(), new Question()); TestSubscriber<List<Question>> subscriber = new TestSubscriber<>(); given(questionDao.getAllQuestions()).willReturn(Flowable.just(questions)); localDataSource.loadQuestions(false).subscribe(subscriber); then(questionDao).should().getAllQuestions(); }
### Question: QuestionLocalDataSource implements QuestionDataSource { @Override public void addQuestion(Question question) { questionDao.insert(question); } @Inject QuestionLocalDataSource(QuestionDao questionDao); @Override Flowable<List<Question>> loadQuestions(boolean forceRemote); @Override void addQuestion(Question question); @Override void clearData(); }### Answer: @Test public void addQuestion_ShouldInsertToDatabase() { Question question = new Question(); localDataSource.addQuestion(question); then(questionDao).should().insert(question); }
### Question: QuestionLocalDataSource implements QuestionDataSource { @Override public void clearData() { questionDao.deleteAll(); } @Inject QuestionLocalDataSource(QuestionDao questionDao); @Override Flowable<List<Question>> loadQuestions(boolean forceRemote); @Override void addQuestion(Question question); @Override void clearData(); }### Answer: @Test public void clearData_ShouldDeleteAllDataInDatabase() { localDataSource.clearData(); then(questionDao).should().deleteAll(); }
### Question: QuestionRemoteDataSource implements QuestionDataSource { @Override public Flowable<List<Question>> loadQuestions(boolean forceRemote) { return questionService.loadQuestionsByTag(Config.ANDROID_QUESTION_TAG).map(QuestionResponse::getQuestions); } @Inject QuestionRemoteDataSource(QuestionService questionService); @Override Flowable<List<Question>> loadQuestions(boolean forceRemote); @Override void addQuestion(Question question); @Override void clearData(); }### Answer: @Test public void loadQuestions_ShouldReturnFromRemoteService() { QuestionResponse questionResponse = new QuestionResponse(); TestSubscriber<List<Question>> subscriber = new TestSubscriber<>(); given(questionService.loadQuestionsByTag(Config.ANDROID_QUESTION_TAG)).willReturn(Flowable.just(questionResponse)); remoteDataSource.loadQuestions(anyBoolean()).subscribe(subscriber); then(questionService).should().loadQuestionsByTag(Config.ANDROID_QUESTION_TAG); }
### Question: QuestionRemoteDataSource implements QuestionDataSource { @Override public void addQuestion(Question question) { throw new UnsupportedOperationException("Unsupported operation"); } @Inject QuestionRemoteDataSource(QuestionService questionService); @Override Flowable<List<Question>> loadQuestions(boolean forceRemote); @Override void addQuestion(Question question); @Override void clearData(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void addQuestion_NoThingToDoWithRemoteService() { Question question = mock(Question.class); remoteDataSource.addQuestion(question); then(questionService).shouldHaveZeroInteractions(); }
### Question: BytecodeAdapterService implements SourceAdapterService<String, CtMethod, CtField, Annotation> { @Override public IsClass toClass(String binaryName) { int arrayCount = 0; while (binaryName.matches(".*" + X_Util.arrayRegex)) { arrayCount += 1; binaryName = binaryName.replaceFirst(X_Util.arrayRegex, ""); } IsClass cls = classes.get(binaryName); return cls.toArray(arrayCount); } BytecodeAdapterService(); BytecodeAdapterService(ClassPool pool); @Override IsClass toClass(String binaryName); @Override IsMethod toMethod(CtMethod type); @Override IsField toField(CtField type); @Override IsAnnotation toAnnotation(Annotation type); IsType[] toTypes(CtClass[] parameterTypes); static MappedIterable<Method> getMethodsInDeclaredOrder(Class<?> type); }### Answer: @Test public void testArrayParser() { IsClass clsArray = service.toClass("java.lang.Class[]"); Assert.assertNotNull(clsArray); } @Test public void testAnnoNoArgs() { IsClass asClass = service.toClass(OuterTestClass.NoTargetAnno.class.getName()); IsAnnotation anno = asClass.getAnnotation(Target.class.getName()); IsAnnotationValue empty = anno.getValue(anno.getMethod("value")); Assert.assertTrue(empty.isArray()); Assert.assertEquals(0, Array.getLength(empty.getRawValue())); } @Test public void testTestClass() { Class<?> cls = getTestClass(); IsClass asClass = service.toClass(cls.getName()); Assert.assertEquals(asClass.getPackage(), cls.getPackage().getName()); Assert.assertEquals(asClass.getEnclosedName(), X_Source.classToEnclosedSourceName(cls)); Assert.assertEquals(asClass.getModifier(), cls.getModifiers()); testAnnos(cls.getDeclaredAnnotations(), asClass); } @Test public void testTestClass_Methods() { Class<?> cls = getTestClass(); IsClass asClass = service.toClass(cls.getName()); for (Method method : cls.getMethods()) { IsMethod imethod = asClass.getMethod(method.getName(), true, method.getParameterTypes()); String testCase = imethod.getQualifiedName() +" != "+method.getName(); Assert.assertNotNull(testCase, imethod); Assert.assertEquals(testCase, method.getName(), imethod.getName()); Assert.assertEquals(testCase, method.getModifiers(), imethod.getModifier()); Assert.assertEquals(testCase, imethod.getReturnType().getQualifiedName(), method.getReturnType().getCanonicalName()); Assert.assertTrue(testCase, BytecodeUtil.typesEqual(imethod.getParameters(), method.getParameterTypes())); Assert.assertTrue(testCase, BytecodeUtil.typesEqual(imethod.getExceptions(), method.getExceptionTypes())); testAnnos(method.getDeclaredAnnotations(), imethod); } } @Test public void testTestClass_Fields() { Class<?> cls = getTestClass(); IsClass asClass = service.toClass(cls.getName()); for (Field field : cls.getFields()) { IsField ifield = asClass.getField(field.getName()); Assert.assertNotNull(field.getName(), ifield); Assert.assertEquals(field.getName(), ifield.getName()); Assert.assertEquals(field.getModifiers(), ifield.getModifier()); testAnnos(field.getDeclaredAnnotations(), ifield); } }
### Question: ToStringUserInterface extends AbstractUserInterface implements Appendable { @Override public String toString() { return b.toString(); } @Override int hashCode(); @Override String toString(); @Override boolean equals(Object obj); @Override Appendable append(CharSequence csq); @Override Appendable append(CharSequence csq, int start, int end); @Override Appendable append(char c); }### Answer: @Test public void testUserToStringNamed() { ToStringUserInterface ui = X_AutoUi.makeUi(MODEL, UserViewNamed.class, ToStringUserInterface.class); Assert.assertEquals("email: email,\nname: name,\nid: id", ui.toString()); } @Test public void testUserToStringWrapped() { UserInterface<User> ui = X_AutoUi.makeUi(MODEL, UserViewWrapped.class, ToStringUserInterface.class); Assert.assertEquals("email: email,\nname: name,\nid: id,\n", ui.toString()); }
### Question: JavaLexer { public static <R> int visitAnnotation (final AnnotationVisitor<R> visitor, final R receiver, final CharSequence chars, int pos) { pos = eatWhitespace(chars, pos); if (pos == chars.length()) { return pos; } int start = pos; try { while(chars.charAt(pos) == '@') { pos = eatJavaname(chars, pos + 1); final String annoName = chars.subSequence(start + 1, pos).toString(); String annoBody = ""; pos = eatWhitespace(chars, pos); if (pos < chars.length() && chars.charAt(pos) == '(') { final int bodyStart = pos+1; pos = eatAnnotationBody(visitor, receiver, chars, pos); annoBody = chars.subSequence(bodyStart, pos).toString(); pos ++; } final AnnotationMemberVisitor<R> bodyVisitor = visitor.visitAnnotation(annoName, annoBody, receiver); if (bodyVisitor != null && annoBody.length() > 0) { visitAnnotationMembers(bodyVisitor, receiver, annoBody, 0); } start = pos = eatWhitespace(chars, pos); if (pos == chars.length()) { break; } } } catch (final IndexOutOfBoundsException e) { error( e, "Error parsing annotation on: " + chars.subSequence(start, chars.length())); } return pos; } JavaLexer(String definition); static int visitJavadoc(final JavadocVisitor<R> visitor, final R receiver, final CharSequence chars, int pos); static int visitAnnotation(final AnnotationVisitor<R> visitor, final R receiver, final CharSequence chars, int pos); static int visitAnnotationMembers(final AnnotationMemberVisitor<R> visitor, final R receiver, final CharSequence chars, int pos); static int visitModifier(final ModifierVisitor<R> visitor, final R receiver, final CharSequence chars, int pos); static int visitGeneric(final GenericVisitor<R> visitor, final R receiver, final CharSequence chars, int pos); static int visitMethodSignature(final MethodVisitor<R> visitor, final R receiver, final CharSequence chars, int pos); static TypeDef extractType(final CharSequence chars, int pos); static SimpleStack<IsGeneric> extractGenerics(final CharSequence chars, final int pos); String getClassName(); int getPrivacy(); int getModifier(); String getSuperClass(); String[] getGenerics(); String[] getImports(); String[] getInterfaces(); boolean isPublic(); boolean isPrivate(); boolean isProtected(); boolean isStatic(); boolean isFinal(); boolean isAbstract(); boolean isNative(); boolean isClass(); boolean isAnnotation(); boolean isEnum(); boolean hasGenerics(); static Iterable<String> findImportsInGeneric(final String generic); static IsParameter lexParam(final CharSequence chars); static int visitClassFile(final ClassVisitor<Param> extractor, final Param receiver, final CharSequence chars, int pos); }### Answer: @Test public void testAnnotationLexer() { final short[] success = new short[1]; final String annoBody = "name=\"one \\\"\\\"two\\\"\\\" three\\\\\", " + "{1, 2.0, false}, values={1, \"string\", com.test.Class.class}"; JavaLexer.visitAnnotation(new AnnotationVisitor<Void>(){ @Override public AnnotationMemberVisitor<Void> visitAnnotation(String annoName, String annoContent, Void receiver) { success[0] = 1; Assert.assertEquals(annoName, "java.lang.Annotation"); Assert.assertEquals(annoContent, annoBody); return null; } }, null, "@java.lang.Annotation(" + annoBody + ")" , 0); Assert.assertEquals(success[0], 1); }
### Question: LogInjector { public Log defaultLogger() { return (level, debug) -> (level == LogLevel.ERROR ? SYS_ERR : SYS_OUT) .print(level, debug); } Log defaultLogger(); }### Answer: @Test public void testDefaultLogging() throws Throwable { final String msg = "Success! " + hashCode(); borrowSout( ()-> LogInjector.DEFAULT.log(LogLevel.INFO, msg) , lines-> Assert.assertEquals("[INFO] " + msg, lines.first()) ); assertTrue("Failed", !failed); Log.defaultLogger().log(LogInjectorTest.class, "Default Logging Works!"); }
### Question: SlideRenderer { public void renderSlide(DomBuffer into, UiContainerExpr slide) { final DomBuffer out; if ("xapi-slide".equals(into.getTagName())) { out = into; } else { out = into.makeTag("xapi-slide"); } slide.getAttribute("id") .mapNullSafe(UiAttrExpr::getExpression) .mapNullSafe(ASTHelper::extractStringValue) .readIfPresent(out::setId); final ComposableXapiVisitor<DomBuffer> visitor = new ComposableXapiVisitor<>(); visitor .withUiContainerExpr((tag, buffer)->{ renderSlideChild(out, tag, visitor, slide); return false; }) .visit(slide.getBody(), out); } void renderSlide(DomBuffer into, UiContainerExpr slide); }### Answer: @Test public void testAllSlidesCanRender() throws IOException, ParseException { items.forAll(item->{ SlideRenderer renderer = new SlideRenderer(); final DomBuffer into = new DomBuffer() .setNewLine(true) .setTrimWhitespace(false); renderer.renderSlide(into, item.out2()); X_Log.info(X_Source.pathToLogLink(item.out1().getResourceName()), "\n", item.out2(), "\nRenders:", into, "\n\n" ); }); }
### Question: CacheUtils { public byte[] getBytes(@NonNull String key) { return getBytes(key, null); } private CacheUtils(@NonNull File cacheDir, long maxSize, int maxCount); static CacheUtils getInstance(); static CacheUtils getInstance(String cacheName); static CacheUtils getInstance(long maxSize, int maxCount); static CacheUtils getInstance(String cacheName, long maxSize, int maxCount); static CacheUtils getInstance(@NonNull File cacheDir); static CacheUtils getInstance(@NonNull File cacheDir, long maxSize, int maxCount); void put(@NonNull String key, @NonNull byte[] value); void put(@NonNull String key, @NonNull byte[] value, int saveTime); byte[] getBytes(@NonNull String key); byte[] getBytes(@NonNull String key, byte[] defaultValue); void put(@NonNull String key, @NonNull String value); void put(@NonNull String key, @NonNull String value, int saveTime); String getString(@NonNull String key); String getString(@NonNull String key, String defaultValue); void put(@NonNull String key, @NonNull JSONObject value); void put(@NonNull String key, @NonNull JSONObject value, int saveTime); JSONObject getJSONObject(@NonNull String key); JSONObject getJSONObject(@NonNull String key, JSONObject defaultValue); void put(@NonNull String key, @NonNull JSONArray value); void put(@NonNull String key, @NonNull JSONArray value, int saveTime); JSONArray getJSONArray(@NonNull String key); JSONArray getJSONArray(@NonNull String key, JSONArray defaultValue); void put(@NonNull String key, @NonNull Bitmap value); void put(@NonNull String key, @NonNull Bitmap value, int saveTime); Bitmap getBitmap(@NonNull String key); Bitmap getBitmap(@NonNull String key, Bitmap defaultValue); void put(@NonNull String key, @NonNull Drawable value); void put(@NonNull String key, @NonNull Drawable value, int saveTime); Drawable getDrawable(@NonNull String key); Drawable getDrawable(@NonNull String key, Drawable defaultValue); void put(@NonNull String key, @NonNull Parcelable value); void put(@NonNull String key, @NonNull Parcelable value, int saveTime); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator, T defaultValue); void put(@NonNull String key, @NonNull Serializable value); void put(@NonNull String key, @NonNull Serializable value, int saveTime); Object getSerializable(@NonNull String key); Object getSerializable(@NonNull String key, Object defaultValue); long getCacheSize(); int getCacheCount(); boolean remove(@NonNull String key); boolean clear(); static final int SEC; static final int MIN; static final int HOUR; static final int DAY; }### Answer: @Test public void getBytes() throws Exception { Assert.assertEquals(mString, new String(mCacheUtils1.getBytes("bytes1"))); Assert.assertEquals(mString, new String(mCacheUtils1.getBytes("bytes1", null))); Assert.assertNull(mCacheUtils1.getBytes("bytes2", null)); Assert.assertEquals(mString, new String(mCacheUtils2.getBytes("bytes2"))); Assert.assertEquals(mString, new String(mCacheUtils2.getBytes("bytes2", null))); Assert.assertNull(mCacheUtils2.getBytes("bytes1", null)); }
### Question: CacheUtils { public String getString(@NonNull String key) { return getString(key, null); } private CacheUtils(@NonNull File cacheDir, long maxSize, int maxCount); static CacheUtils getInstance(); static CacheUtils getInstance(String cacheName); static CacheUtils getInstance(long maxSize, int maxCount); static CacheUtils getInstance(String cacheName, long maxSize, int maxCount); static CacheUtils getInstance(@NonNull File cacheDir); static CacheUtils getInstance(@NonNull File cacheDir, long maxSize, int maxCount); void put(@NonNull String key, @NonNull byte[] value); void put(@NonNull String key, @NonNull byte[] value, int saveTime); byte[] getBytes(@NonNull String key); byte[] getBytes(@NonNull String key, byte[] defaultValue); void put(@NonNull String key, @NonNull String value); void put(@NonNull String key, @NonNull String value, int saveTime); String getString(@NonNull String key); String getString(@NonNull String key, String defaultValue); void put(@NonNull String key, @NonNull JSONObject value); void put(@NonNull String key, @NonNull JSONObject value, int saveTime); JSONObject getJSONObject(@NonNull String key); JSONObject getJSONObject(@NonNull String key, JSONObject defaultValue); void put(@NonNull String key, @NonNull JSONArray value); void put(@NonNull String key, @NonNull JSONArray value, int saveTime); JSONArray getJSONArray(@NonNull String key); JSONArray getJSONArray(@NonNull String key, JSONArray defaultValue); void put(@NonNull String key, @NonNull Bitmap value); void put(@NonNull String key, @NonNull Bitmap value, int saveTime); Bitmap getBitmap(@NonNull String key); Bitmap getBitmap(@NonNull String key, Bitmap defaultValue); void put(@NonNull String key, @NonNull Drawable value); void put(@NonNull String key, @NonNull Drawable value, int saveTime); Drawable getDrawable(@NonNull String key); Drawable getDrawable(@NonNull String key, Drawable defaultValue); void put(@NonNull String key, @NonNull Parcelable value); void put(@NonNull String key, @NonNull Parcelable value, int saveTime); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator, T defaultValue); void put(@NonNull String key, @NonNull Serializable value); void put(@NonNull String key, @NonNull Serializable value, int saveTime); Object getSerializable(@NonNull String key); Object getSerializable(@NonNull String key, Object defaultValue); long getCacheSize(); int getCacheCount(); boolean remove(@NonNull String key); boolean clear(); static final int SEC; static final int MIN; static final int HOUR; static final int DAY; }### Answer: @Test public void getString() throws Exception { Assert.assertEquals(mString, mCacheUtils1.getString("string1")); Assert.assertEquals(mString, mCacheUtils1.getString("string1", null)); Assert.assertNull(mCacheUtils1.getString("string2", null)); Assert.assertEquals(mString, mCacheUtils2.getString("string2")); Assert.assertEquals(mString, mCacheUtils2.getString("string2", null)); Assert.assertNull(mCacheUtils2.getString("string1", null)); }
### Question: CacheUtils { public JSONObject getJSONObject(@NonNull String key) { return getJSONObject(key, null); } private CacheUtils(@NonNull File cacheDir, long maxSize, int maxCount); static CacheUtils getInstance(); static CacheUtils getInstance(String cacheName); static CacheUtils getInstance(long maxSize, int maxCount); static CacheUtils getInstance(String cacheName, long maxSize, int maxCount); static CacheUtils getInstance(@NonNull File cacheDir); static CacheUtils getInstance(@NonNull File cacheDir, long maxSize, int maxCount); void put(@NonNull String key, @NonNull byte[] value); void put(@NonNull String key, @NonNull byte[] value, int saveTime); byte[] getBytes(@NonNull String key); byte[] getBytes(@NonNull String key, byte[] defaultValue); void put(@NonNull String key, @NonNull String value); void put(@NonNull String key, @NonNull String value, int saveTime); String getString(@NonNull String key); String getString(@NonNull String key, String defaultValue); void put(@NonNull String key, @NonNull JSONObject value); void put(@NonNull String key, @NonNull JSONObject value, int saveTime); JSONObject getJSONObject(@NonNull String key); JSONObject getJSONObject(@NonNull String key, JSONObject defaultValue); void put(@NonNull String key, @NonNull JSONArray value); void put(@NonNull String key, @NonNull JSONArray value, int saveTime); JSONArray getJSONArray(@NonNull String key); JSONArray getJSONArray(@NonNull String key, JSONArray defaultValue); void put(@NonNull String key, @NonNull Bitmap value); void put(@NonNull String key, @NonNull Bitmap value, int saveTime); Bitmap getBitmap(@NonNull String key); Bitmap getBitmap(@NonNull String key, Bitmap defaultValue); void put(@NonNull String key, @NonNull Drawable value); void put(@NonNull String key, @NonNull Drawable value, int saveTime); Drawable getDrawable(@NonNull String key); Drawable getDrawable(@NonNull String key, Drawable defaultValue); void put(@NonNull String key, @NonNull Parcelable value); void put(@NonNull String key, @NonNull Parcelable value, int saveTime); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator, T defaultValue); void put(@NonNull String key, @NonNull Serializable value); void put(@NonNull String key, @NonNull Serializable value, int saveTime); Object getSerializable(@NonNull String key); Object getSerializable(@NonNull String key, Object defaultValue); long getCacheSize(); int getCacheCount(); boolean remove(@NonNull String key); boolean clear(); static final int SEC; static final int MIN; static final int HOUR; static final int DAY; }### Answer: @Test public void getJSONObject() throws Exception { Assert.assertEquals(mJSONObject.toString(), mCacheUtils1.getJSONObject("jsonObject1").toString()); Assert.assertEquals(mJSONObject.toString(), mCacheUtils1.getJSONObject("jsonObject1", null).toString()); Assert.assertNull(mCacheUtils1.getJSONObject("jsonObject2", null)); Assert.assertEquals(mJSONObject.toString(), mCacheUtils2.getJSONObject("jsonObject2").toString()); Assert.assertEquals(mJSONObject.toString(), mCacheUtils2.getJSONObject("jsonObject2", null).toString()); Assert.assertNull(mCacheUtils2.getJSONObject("jsonObject1", null)); }
### Question: CacheUtils { public JSONArray getJSONArray(@NonNull String key) { return getJSONArray(key, null); } private CacheUtils(@NonNull File cacheDir, long maxSize, int maxCount); static CacheUtils getInstance(); static CacheUtils getInstance(String cacheName); static CacheUtils getInstance(long maxSize, int maxCount); static CacheUtils getInstance(String cacheName, long maxSize, int maxCount); static CacheUtils getInstance(@NonNull File cacheDir); static CacheUtils getInstance(@NonNull File cacheDir, long maxSize, int maxCount); void put(@NonNull String key, @NonNull byte[] value); void put(@NonNull String key, @NonNull byte[] value, int saveTime); byte[] getBytes(@NonNull String key); byte[] getBytes(@NonNull String key, byte[] defaultValue); void put(@NonNull String key, @NonNull String value); void put(@NonNull String key, @NonNull String value, int saveTime); String getString(@NonNull String key); String getString(@NonNull String key, String defaultValue); void put(@NonNull String key, @NonNull JSONObject value); void put(@NonNull String key, @NonNull JSONObject value, int saveTime); JSONObject getJSONObject(@NonNull String key); JSONObject getJSONObject(@NonNull String key, JSONObject defaultValue); void put(@NonNull String key, @NonNull JSONArray value); void put(@NonNull String key, @NonNull JSONArray value, int saveTime); JSONArray getJSONArray(@NonNull String key); JSONArray getJSONArray(@NonNull String key, JSONArray defaultValue); void put(@NonNull String key, @NonNull Bitmap value); void put(@NonNull String key, @NonNull Bitmap value, int saveTime); Bitmap getBitmap(@NonNull String key); Bitmap getBitmap(@NonNull String key, Bitmap defaultValue); void put(@NonNull String key, @NonNull Drawable value); void put(@NonNull String key, @NonNull Drawable value, int saveTime); Drawable getDrawable(@NonNull String key); Drawable getDrawable(@NonNull String key, Drawable defaultValue); void put(@NonNull String key, @NonNull Parcelable value); void put(@NonNull String key, @NonNull Parcelable value, int saveTime); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator, T defaultValue); void put(@NonNull String key, @NonNull Serializable value); void put(@NonNull String key, @NonNull Serializable value, int saveTime); Object getSerializable(@NonNull String key); Object getSerializable(@NonNull String key, Object defaultValue); long getCacheSize(); int getCacheCount(); boolean remove(@NonNull String key); boolean clear(); static final int SEC; static final int MIN; static final int HOUR; static final int DAY; }### Answer: @Test public void getJSONArray() throws Exception { Assert.assertEquals(mJSONArray.toString(), mCacheUtils1.getJSONArray("jsonArray1").toString()); Assert.assertEquals(mJSONArray.toString(), mCacheUtils1.getJSONArray("jsonArray1", null).toString()); Assert.assertNull(mCacheUtils1.getJSONArray("jsonArray2", null)); Assert.assertEquals(mJSONArray.toString(), mCacheUtils2.getJSONArray("jsonArray2").toString()); Assert.assertEquals(mJSONArray.toString(), mCacheUtils2.getJSONArray("jsonArray2", null).toString()); Assert.assertNull(mCacheUtils2.getJSONArray("jsonArray1", null)); }
### Question: CacheUtils { public Bitmap getBitmap(@NonNull String key) { return getBitmap(key, null); } private CacheUtils(@NonNull File cacheDir, long maxSize, int maxCount); static CacheUtils getInstance(); static CacheUtils getInstance(String cacheName); static CacheUtils getInstance(long maxSize, int maxCount); static CacheUtils getInstance(String cacheName, long maxSize, int maxCount); static CacheUtils getInstance(@NonNull File cacheDir); static CacheUtils getInstance(@NonNull File cacheDir, long maxSize, int maxCount); void put(@NonNull String key, @NonNull byte[] value); void put(@NonNull String key, @NonNull byte[] value, int saveTime); byte[] getBytes(@NonNull String key); byte[] getBytes(@NonNull String key, byte[] defaultValue); void put(@NonNull String key, @NonNull String value); void put(@NonNull String key, @NonNull String value, int saveTime); String getString(@NonNull String key); String getString(@NonNull String key, String defaultValue); void put(@NonNull String key, @NonNull JSONObject value); void put(@NonNull String key, @NonNull JSONObject value, int saveTime); JSONObject getJSONObject(@NonNull String key); JSONObject getJSONObject(@NonNull String key, JSONObject defaultValue); void put(@NonNull String key, @NonNull JSONArray value); void put(@NonNull String key, @NonNull JSONArray value, int saveTime); JSONArray getJSONArray(@NonNull String key); JSONArray getJSONArray(@NonNull String key, JSONArray defaultValue); void put(@NonNull String key, @NonNull Bitmap value); void put(@NonNull String key, @NonNull Bitmap value, int saveTime); Bitmap getBitmap(@NonNull String key); Bitmap getBitmap(@NonNull String key, Bitmap defaultValue); void put(@NonNull String key, @NonNull Drawable value); void put(@NonNull String key, @NonNull Drawable value, int saveTime); Drawable getDrawable(@NonNull String key); Drawable getDrawable(@NonNull String key, Drawable defaultValue); void put(@NonNull String key, @NonNull Parcelable value); void put(@NonNull String key, @NonNull Parcelable value, int saveTime); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator, T defaultValue); void put(@NonNull String key, @NonNull Serializable value); void put(@NonNull String key, @NonNull Serializable value, int saveTime); Object getSerializable(@NonNull String key); Object getSerializable(@NonNull String key, Object defaultValue); long getCacheSize(); int getCacheCount(); boolean remove(@NonNull String key); boolean clear(); static final int SEC; static final int MIN; static final int HOUR; static final int DAY; }### Answer: @Test public void getBitmap() throws Exception { Assert.assertTrue(mCacheUtils1.getString("bitmap1").equals("Bitmap (100 x 100) compressed as PNG with quality 100")); Assert.assertTrue(mCacheUtils1.getString("bitmap1", null).equals("Bitmap (100 x 100) compressed as PNG with quality 100")); Assert.assertNull(mCacheUtils1.getString("bitmap2", null)); Assert.assertTrue(mCacheUtils2.getString("bitmap2").equals("Bitmap (100 x 100) compressed as PNG with quality 100")); Assert.assertTrue(mCacheUtils2.getString("bitmap2", null).equals("Bitmap (100 x 100) compressed as PNG with quality 100")); Assert.assertNull(mCacheUtils2.getString("bitmap1", null)); }
### Question: CacheUtils { public Drawable getDrawable(@NonNull String key) { return getDrawable(key, null); } private CacheUtils(@NonNull File cacheDir, long maxSize, int maxCount); static CacheUtils getInstance(); static CacheUtils getInstance(String cacheName); static CacheUtils getInstance(long maxSize, int maxCount); static CacheUtils getInstance(String cacheName, long maxSize, int maxCount); static CacheUtils getInstance(@NonNull File cacheDir); static CacheUtils getInstance(@NonNull File cacheDir, long maxSize, int maxCount); void put(@NonNull String key, @NonNull byte[] value); void put(@NonNull String key, @NonNull byte[] value, int saveTime); byte[] getBytes(@NonNull String key); byte[] getBytes(@NonNull String key, byte[] defaultValue); void put(@NonNull String key, @NonNull String value); void put(@NonNull String key, @NonNull String value, int saveTime); String getString(@NonNull String key); String getString(@NonNull String key, String defaultValue); void put(@NonNull String key, @NonNull JSONObject value); void put(@NonNull String key, @NonNull JSONObject value, int saveTime); JSONObject getJSONObject(@NonNull String key); JSONObject getJSONObject(@NonNull String key, JSONObject defaultValue); void put(@NonNull String key, @NonNull JSONArray value); void put(@NonNull String key, @NonNull JSONArray value, int saveTime); JSONArray getJSONArray(@NonNull String key); JSONArray getJSONArray(@NonNull String key, JSONArray defaultValue); void put(@NonNull String key, @NonNull Bitmap value); void put(@NonNull String key, @NonNull Bitmap value, int saveTime); Bitmap getBitmap(@NonNull String key); Bitmap getBitmap(@NonNull String key, Bitmap defaultValue); void put(@NonNull String key, @NonNull Drawable value); void put(@NonNull String key, @NonNull Drawable value, int saveTime); Drawable getDrawable(@NonNull String key); Drawable getDrawable(@NonNull String key, Drawable defaultValue); void put(@NonNull String key, @NonNull Parcelable value); void put(@NonNull String key, @NonNull Parcelable value, int saveTime); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator, T defaultValue); void put(@NonNull String key, @NonNull Serializable value); void put(@NonNull String key, @NonNull Serializable value, int saveTime); Object getSerializable(@NonNull String key); Object getSerializable(@NonNull String key, Object defaultValue); long getCacheSize(); int getCacheCount(); boolean remove(@NonNull String key); boolean clear(); static final int SEC; static final int MIN; static final int HOUR; static final int DAY; }### Answer: @Test public void getDrawable() throws Exception { Assert.assertTrue(mCacheUtils1.getString("drawable1").equals("Bitmap (100 x 100) compressed as PNG with quality 100")); Assert.assertTrue(mCacheUtils1.getString("drawable1", null).equals("Bitmap (100 x 100) compressed as PNG with quality 100")); Assert.assertNull(mCacheUtils1.getString("drawable2", null)); Assert.assertTrue(mCacheUtils2.getString("drawable2").equals("Bitmap (100 x 100) compressed as PNG with quality 100")); Assert.assertTrue(mCacheUtils2.getString("drawable2", null).equals("Bitmap (100 x 100) compressed as PNG with quality 100")); Assert.assertNull(mCacheUtils2.getString("drawable1", null)); }
### Question: CacheUtils { public <T> T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator) { return getParcelable(key, creator, null); } private CacheUtils(@NonNull File cacheDir, long maxSize, int maxCount); static CacheUtils getInstance(); static CacheUtils getInstance(String cacheName); static CacheUtils getInstance(long maxSize, int maxCount); static CacheUtils getInstance(String cacheName, long maxSize, int maxCount); static CacheUtils getInstance(@NonNull File cacheDir); static CacheUtils getInstance(@NonNull File cacheDir, long maxSize, int maxCount); void put(@NonNull String key, @NonNull byte[] value); void put(@NonNull String key, @NonNull byte[] value, int saveTime); byte[] getBytes(@NonNull String key); byte[] getBytes(@NonNull String key, byte[] defaultValue); void put(@NonNull String key, @NonNull String value); void put(@NonNull String key, @NonNull String value, int saveTime); String getString(@NonNull String key); String getString(@NonNull String key, String defaultValue); void put(@NonNull String key, @NonNull JSONObject value); void put(@NonNull String key, @NonNull JSONObject value, int saveTime); JSONObject getJSONObject(@NonNull String key); JSONObject getJSONObject(@NonNull String key, JSONObject defaultValue); void put(@NonNull String key, @NonNull JSONArray value); void put(@NonNull String key, @NonNull JSONArray value, int saveTime); JSONArray getJSONArray(@NonNull String key); JSONArray getJSONArray(@NonNull String key, JSONArray defaultValue); void put(@NonNull String key, @NonNull Bitmap value); void put(@NonNull String key, @NonNull Bitmap value, int saveTime); Bitmap getBitmap(@NonNull String key); Bitmap getBitmap(@NonNull String key, Bitmap defaultValue); void put(@NonNull String key, @NonNull Drawable value); void put(@NonNull String key, @NonNull Drawable value, int saveTime); Drawable getDrawable(@NonNull String key); Drawable getDrawable(@NonNull String key, Drawable defaultValue); void put(@NonNull String key, @NonNull Parcelable value); void put(@NonNull String key, @NonNull Parcelable value, int saveTime); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator, T defaultValue); void put(@NonNull String key, @NonNull Serializable value); void put(@NonNull String key, @NonNull Serializable value, int saveTime); Object getSerializable(@NonNull String key); Object getSerializable(@NonNull String key, Object defaultValue); long getCacheSize(); int getCacheCount(); boolean remove(@NonNull String key); boolean clear(); static final int SEC; static final int MIN; static final int HOUR; static final int DAY; }### Answer: @Test public void getParcel() throws Exception { Assert.assertTrue(mCacheUtils1.getParcelable("parcelable1", ParcelableTest.CREATOR).equals(mParcelableTest)); Assert.assertTrue(mCacheUtils1.getParcelable("parcelable1", ParcelableTest.CREATOR, null).equals(mParcelableTest)); Assert.assertNull(mCacheUtils1.getParcelable("parcelable2", ParcelableTest.CREATOR, null)); Assert.assertTrue(mCacheUtils2.getParcelable("parcelable2", ParcelableTest.CREATOR).equals(mParcelableTest)); Assert.assertTrue(mCacheUtils2.getParcelable("parcelable2", ParcelableTest.CREATOR, null).equals(mParcelableTest)); Assert.assertNull(mCacheUtils2.getParcelable("parcelable1", ParcelableTest.CREATOR, null)); }
### Question: CacheUtils { public Object getSerializable(@NonNull String key) { return getSerializable(key, null); } private CacheUtils(@NonNull File cacheDir, long maxSize, int maxCount); static CacheUtils getInstance(); static CacheUtils getInstance(String cacheName); static CacheUtils getInstance(long maxSize, int maxCount); static CacheUtils getInstance(String cacheName, long maxSize, int maxCount); static CacheUtils getInstance(@NonNull File cacheDir); static CacheUtils getInstance(@NonNull File cacheDir, long maxSize, int maxCount); void put(@NonNull String key, @NonNull byte[] value); void put(@NonNull String key, @NonNull byte[] value, int saveTime); byte[] getBytes(@NonNull String key); byte[] getBytes(@NonNull String key, byte[] defaultValue); void put(@NonNull String key, @NonNull String value); void put(@NonNull String key, @NonNull String value, int saveTime); String getString(@NonNull String key); String getString(@NonNull String key, String defaultValue); void put(@NonNull String key, @NonNull JSONObject value); void put(@NonNull String key, @NonNull JSONObject value, int saveTime); JSONObject getJSONObject(@NonNull String key); JSONObject getJSONObject(@NonNull String key, JSONObject defaultValue); void put(@NonNull String key, @NonNull JSONArray value); void put(@NonNull String key, @NonNull JSONArray value, int saveTime); JSONArray getJSONArray(@NonNull String key); JSONArray getJSONArray(@NonNull String key, JSONArray defaultValue); void put(@NonNull String key, @NonNull Bitmap value); void put(@NonNull String key, @NonNull Bitmap value, int saveTime); Bitmap getBitmap(@NonNull String key); Bitmap getBitmap(@NonNull String key, Bitmap defaultValue); void put(@NonNull String key, @NonNull Drawable value); void put(@NonNull String key, @NonNull Drawable value, int saveTime); Drawable getDrawable(@NonNull String key); Drawable getDrawable(@NonNull String key, Drawable defaultValue); void put(@NonNull String key, @NonNull Parcelable value); void put(@NonNull String key, @NonNull Parcelable value, int saveTime); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator, T defaultValue); void put(@NonNull String key, @NonNull Serializable value); void put(@NonNull String key, @NonNull Serializable value, int saveTime); Object getSerializable(@NonNull String key); Object getSerializable(@NonNull String key, Object defaultValue); long getCacheSize(); int getCacheCount(); boolean remove(@NonNull String key); boolean clear(); static final int SEC; static final int MIN; static final int HOUR; static final int DAY; }### Answer: @Test public void getSerializable() throws Exception { Assert.assertTrue(mCacheUtils1.getSerializable("serializable1").equals(mSerializableTest)); Assert.assertTrue(mCacheUtils1.getSerializable("serializable1", null).equals(mSerializableTest)); Assert.assertNull(mCacheUtils1.getSerializable("parcelable2", null)); Assert.assertTrue(mCacheUtils2.getSerializable("serializable2").equals(mSerializableTest)); Assert.assertTrue(mCacheUtils2.getSerializable("serializable2", null).equals(mSerializableTest)); Assert.assertNull(mCacheUtils2.getSerializable("parcelable1", null)); }
### Question: CacheUtils { public long getCacheSize() { return mCacheManager.getCacheSize(); } private CacheUtils(@NonNull File cacheDir, long maxSize, int maxCount); static CacheUtils getInstance(); static CacheUtils getInstance(String cacheName); static CacheUtils getInstance(long maxSize, int maxCount); static CacheUtils getInstance(String cacheName, long maxSize, int maxCount); static CacheUtils getInstance(@NonNull File cacheDir); static CacheUtils getInstance(@NonNull File cacheDir, long maxSize, int maxCount); void put(@NonNull String key, @NonNull byte[] value); void put(@NonNull String key, @NonNull byte[] value, int saveTime); byte[] getBytes(@NonNull String key); byte[] getBytes(@NonNull String key, byte[] defaultValue); void put(@NonNull String key, @NonNull String value); void put(@NonNull String key, @NonNull String value, int saveTime); String getString(@NonNull String key); String getString(@NonNull String key, String defaultValue); void put(@NonNull String key, @NonNull JSONObject value); void put(@NonNull String key, @NonNull JSONObject value, int saveTime); JSONObject getJSONObject(@NonNull String key); JSONObject getJSONObject(@NonNull String key, JSONObject defaultValue); void put(@NonNull String key, @NonNull JSONArray value); void put(@NonNull String key, @NonNull JSONArray value, int saveTime); JSONArray getJSONArray(@NonNull String key); JSONArray getJSONArray(@NonNull String key, JSONArray defaultValue); void put(@NonNull String key, @NonNull Bitmap value); void put(@NonNull String key, @NonNull Bitmap value, int saveTime); Bitmap getBitmap(@NonNull String key); Bitmap getBitmap(@NonNull String key, Bitmap defaultValue); void put(@NonNull String key, @NonNull Drawable value); void put(@NonNull String key, @NonNull Drawable value, int saveTime); Drawable getDrawable(@NonNull String key); Drawable getDrawable(@NonNull String key, Drawable defaultValue); void put(@NonNull String key, @NonNull Parcelable value); void put(@NonNull String key, @NonNull Parcelable value, int saveTime); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator, T defaultValue); void put(@NonNull String key, @NonNull Serializable value); void put(@NonNull String key, @NonNull Serializable value, int saveTime); Object getSerializable(@NonNull String key); Object getSerializable(@NonNull String key, Object defaultValue); long getCacheSize(); int getCacheCount(); boolean remove(@NonNull String key); boolean clear(); static final int SEC; static final int MIN; static final int HOUR; static final int DAY; }### Answer: @Test public void getCacheSize() throws Exception { Assert.assertEquals(FileUtils.getDirLength(file1), mCacheUtils1.getCacheSize()); Assert.assertEquals(FileUtils.getDirLength(file2), mCacheUtils2.getCacheSize()); }
### Question: CacheUtils { public int getCacheCount() { return mCacheManager.getCacheCount(); } private CacheUtils(@NonNull File cacheDir, long maxSize, int maxCount); static CacheUtils getInstance(); static CacheUtils getInstance(String cacheName); static CacheUtils getInstance(long maxSize, int maxCount); static CacheUtils getInstance(String cacheName, long maxSize, int maxCount); static CacheUtils getInstance(@NonNull File cacheDir); static CacheUtils getInstance(@NonNull File cacheDir, long maxSize, int maxCount); void put(@NonNull String key, @NonNull byte[] value); void put(@NonNull String key, @NonNull byte[] value, int saveTime); byte[] getBytes(@NonNull String key); byte[] getBytes(@NonNull String key, byte[] defaultValue); void put(@NonNull String key, @NonNull String value); void put(@NonNull String key, @NonNull String value, int saveTime); String getString(@NonNull String key); String getString(@NonNull String key, String defaultValue); void put(@NonNull String key, @NonNull JSONObject value); void put(@NonNull String key, @NonNull JSONObject value, int saveTime); JSONObject getJSONObject(@NonNull String key); JSONObject getJSONObject(@NonNull String key, JSONObject defaultValue); void put(@NonNull String key, @NonNull JSONArray value); void put(@NonNull String key, @NonNull JSONArray value, int saveTime); JSONArray getJSONArray(@NonNull String key); JSONArray getJSONArray(@NonNull String key, JSONArray defaultValue); void put(@NonNull String key, @NonNull Bitmap value); void put(@NonNull String key, @NonNull Bitmap value, int saveTime); Bitmap getBitmap(@NonNull String key); Bitmap getBitmap(@NonNull String key, Bitmap defaultValue); void put(@NonNull String key, @NonNull Drawable value); void put(@NonNull String key, @NonNull Drawable value, int saveTime); Drawable getDrawable(@NonNull String key); Drawable getDrawable(@NonNull String key, Drawable defaultValue); void put(@NonNull String key, @NonNull Parcelable value); void put(@NonNull String key, @NonNull Parcelable value, int saveTime); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator, T defaultValue); void put(@NonNull String key, @NonNull Serializable value); void put(@NonNull String key, @NonNull Serializable value, int saveTime); Object getSerializable(@NonNull String key); Object getSerializable(@NonNull String key, Object defaultValue); long getCacheSize(); int getCacheCount(); boolean remove(@NonNull String key); boolean clear(); static final int SEC; static final int MIN; static final int HOUR; static final int DAY; }### Answer: @Test public void getCacheCount() throws Exception { Assert.assertEquals(8, mCacheUtils1.getCacheCount()); Assert.assertEquals(8, mCacheUtils2.getCacheCount()); }
### Question: CacheUtils { public boolean remove(@NonNull String key) { return mCacheManager.removeByKey(key); } private CacheUtils(@NonNull File cacheDir, long maxSize, int maxCount); static CacheUtils getInstance(); static CacheUtils getInstance(String cacheName); static CacheUtils getInstance(long maxSize, int maxCount); static CacheUtils getInstance(String cacheName, long maxSize, int maxCount); static CacheUtils getInstance(@NonNull File cacheDir); static CacheUtils getInstance(@NonNull File cacheDir, long maxSize, int maxCount); void put(@NonNull String key, @NonNull byte[] value); void put(@NonNull String key, @NonNull byte[] value, int saveTime); byte[] getBytes(@NonNull String key); byte[] getBytes(@NonNull String key, byte[] defaultValue); void put(@NonNull String key, @NonNull String value); void put(@NonNull String key, @NonNull String value, int saveTime); String getString(@NonNull String key); String getString(@NonNull String key, String defaultValue); void put(@NonNull String key, @NonNull JSONObject value); void put(@NonNull String key, @NonNull JSONObject value, int saveTime); JSONObject getJSONObject(@NonNull String key); JSONObject getJSONObject(@NonNull String key, JSONObject defaultValue); void put(@NonNull String key, @NonNull JSONArray value); void put(@NonNull String key, @NonNull JSONArray value, int saveTime); JSONArray getJSONArray(@NonNull String key); JSONArray getJSONArray(@NonNull String key, JSONArray defaultValue); void put(@NonNull String key, @NonNull Bitmap value); void put(@NonNull String key, @NonNull Bitmap value, int saveTime); Bitmap getBitmap(@NonNull String key); Bitmap getBitmap(@NonNull String key, Bitmap defaultValue); void put(@NonNull String key, @NonNull Drawable value); void put(@NonNull String key, @NonNull Drawable value, int saveTime); Drawable getDrawable(@NonNull String key); Drawable getDrawable(@NonNull String key, Drawable defaultValue); void put(@NonNull String key, @NonNull Parcelable value); void put(@NonNull String key, @NonNull Parcelable value, int saveTime); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator); T getParcelable(@NonNull String key, @NonNull Parcelable.Creator<T> creator, T defaultValue); void put(@NonNull String key, @NonNull Serializable value); void put(@NonNull String key, @NonNull Serializable value, int saveTime); Object getSerializable(@NonNull String key); Object getSerializable(@NonNull String key, Object defaultValue); long getCacheSize(); int getCacheCount(); boolean remove(@NonNull String key); boolean clear(); static final int SEC; static final int MIN; static final int HOUR; static final int DAY; }### Answer: @Test public void remove() throws Exception { Assert.assertNotNull(mCacheUtils1.getString("string1")); mCacheUtils1.remove("string1"); Assert.assertNull(mCacheUtils1.getString("string1")); Assert.assertNotNull(mCacheUtils2.getString("string2")); mCacheUtils2.remove("string2"); Assert.assertNull(mCacheUtils2.getString("string2")); }
### Question: SPUtils { public String getString(@NonNull String key) { return getString(key, ""); } private SPUtils(String spName); static SPUtils getInstance(); static SPUtils getInstance(String spName); void put(@NonNull String key, @NonNull String value); String getString(@NonNull String key); String getString(@NonNull String key, @NonNull String defaultValue); void put(@NonNull String key, int value); int getInt(@NonNull String key); int getInt(@NonNull String key, int defaultValue); void put(@NonNull String key, long value); long getLong(@NonNull String key); long getLong(@NonNull String key, long defaultValue); void put(@NonNull String key, float value); float getFloat(@NonNull String key); float getFloat(@NonNull String key, float defaultValue); void put(@NonNull String key, boolean value); boolean getBoolean(@NonNull String key); boolean getBoolean(@NonNull String key, boolean defaultValue); void put(@NonNull String key, @NonNull Set<String> values); Set<String> getStringSet(@NonNull String key); Set<String> getStringSet(@NonNull String key, @NonNull Set<String> defaultValue); Map<String, ?> getAll(); boolean contains(@NonNull String key); void remove(@NonNull String key); void clear(); }### Answer: @Test public void getString() throws Exception { Assert.assertEquals("stringVal1", spUtils1.getString("stringKey1")); Assert.assertEquals("stringVal", spUtils1.getString("stringKey", "stringVal")); Assert.assertEquals("", spUtils1.getString("stringKey")); Assert.assertEquals("stringVal2", spUtils2.getString("stringKey2")); Assert.assertEquals("stringVal", spUtils2.getString("stringKey", "stringVal")); Assert.assertEquals("", spUtils2.getString("stringKey")); }
### Question: SPUtils { public int getInt(@NonNull String key) { return getInt(key, -1); } private SPUtils(String spName); static SPUtils getInstance(); static SPUtils getInstance(String spName); void put(@NonNull String key, @NonNull String value); String getString(@NonNull String key); String getString(@NonNull String key, @NonNull String defaultValue); void put(@NonNull String key, int value); int getInt(@NonNull String key); int getInt(@NonNull String key, int defaultValue); void put(@NonNull String key, long value); long getLong(@NonNull String key); long getLong(@NonNull String key, long defaultValue); void put(@NonNull String key, float value); float getFloat(@NonNull String key); float getFloat(@NonNull String key, float defaultValue); void put(@NonNull String key, boolean value); boolean getBoolean(@NonNull String key); boolean getBoolean(@NonNull String key, boolean defaultValue); void put(@NonNull String key, @NonNull Set<String> values); Set<String> getStringSet(@NonNull String key); Set<String> getStringSet(@NonNull String key, @NonNull Set<String> defaultValue); Map<String, ?> getAll(); boolean contains(@NonNull String key); void remove(@NonNull String key); void clear(); }### Answer: @Test public void getInt() throws Exception { Assert.assertEquals(1, spUtils1.getInt("intKey1")); Assert.assertEquals(2048, spUtils1.getInt("intKey", 2048)); Assert.assertEquals(-1, spUtils1.getInt("intKey")); Assert.assertEquals(2, spUtils2.getInt("intKey2")); Assert.assertEquals(2048, spUtils2.getInt("intKey", 2048)); Assert.assertEquals(-1, spUtils2.getInt("intKey")); }
### Question: SPUtils { public long getLong(@NonNull String key) { return getLong(key, -1L); } private SPUtils(String spName); static SPUtils getInstance(); static SPUtils getInstance(String spName); void put(@NonNull String key, @NonNull String value); String getString(@NonNull String key); String getString(@NonNull String key, @NonNull String defaultValue); void put(@NonNull String key, int value); int getInt(@NonNull String key); int getInt(@NonNull String key, int defaultValue); void put(@NonNull String key, long value); long getLong(@NonNull String key); long getLong(@NonNull String key, long defaultValue); void put(@NonNull String key, float value); float getFloat(@NonNull String key); float getFloat(@NonNull String key, float defaultValue); void put(@NonNull String key, boolean value); boolean getBoolean(@NonNull String key); boolean getBoolean(@NonNull String key, boolean defaultValue); void put(@NonNull String key, @NonNull Set<String> values); Set<String> getStringSet(@NonNull String key); Set<String> getStringSet(@NonNull String key, @NonNull Set<String> defaultValue); Map<String, ?> getAll(); boolean contains(@NonNull String key); void remove(@NonNull String key); void clear(); }### Answer: @Test public void getLong() throws Exception { Assert.assertEquals(1L, spUtils1.getLong("longKey1")); Assert.assertEquals(2048L, spUtils1.getLong("longKey", 2048)); Assert.assertEquals(-1L, spUtils1.getLong("longKey")); Assert.assertEquals(2L, spUtils2.getLong("longKey2")); Assert.assertEquals(2048L, spUtils2.getLong("longKey", 2048)); Assert.assertEquals(-1L, spUtils2.getLong("longKey")); }
### Question: SPUtils { public float getFloat(@NonNull String key) { return getFloat(key, -1f); } private SPUtils(String spName); static SPUtils getInstance(); static SPUtils getInstance(String spName); void put(@NonNull String key, @NonNull String value); String getString(@NonNull String key); String getString(@NonNull String key, @NonNull String defaultValue); void put(@NonNull String key, int value); int getInt(@NonNull String key); int getInt(@NonNull String key, int defaultValue); void put(@NonNull String key, long value); long getLong(@NonNull String key); long getLong(@NonNull String key, long defaultValue); void put(@NonNull String key, float value); float getFloat(@NonNull String key); float getFloat(@NonNull String key, float defaultValue); void put(@NonNull String key, boolean value); boolean getBoolean(@NonNull String key); boolean getBoolean(@NonNull String key, boolean defaultValue); void put(@NonNull String key, @NonNull Set<String> values); Set<String> getStringSet(@NonNull String key); Set<String> getStringSet(@NonNull String key, @NonNull Set<String> defaultValue); Map<String, ?> getAll(); boolean contains(@NonNull String key); void remove(@NonNull String key); void clear(); }### Answer: @Test public void getFloat() throws Exception { Assert.assertEquals(1f, spUtils1.getFloat("floatKey1"), 0f); Assert.assertEquals(2048f, spUtils1.getFloat("floatKey", 2048f), 0f); Assert.assertEquals(-1f, spUtils1.getFloat("floatKey"), 0f); Assert.assertEquals(2f, spUtils2.getFloat("floatKey2"), 0f); Assert.assertEquals(2048f, spUtils2.getFloat("floatKey", 2048f), 0f); Assert.assertEquals(-1f, spUtils2.getFloat("floatKey"), 0f); }
### Question: SPUtils { public boolean getBoolean(@NonNull String key) { return getBoolean(key, false); } private SPUtils(String spName); static SPUtils getInstance(); static SPUtils getInstance(String spName); void put(@NonNull String key, @NonNull String value); String getString(@NonNull String key); String getString(@NonNull String key, @NonNull String defaultValue); void put(@NonNull String key, int value); int getInt(@NonNull String key); int getInt(@NonNull String key, int defaultValue); void put(@NonNull String key, long value); long getLong(@NonNull String key); long getLong(@NonNull String key, long defaultValue); void put(@NonNull String key, float value); float getFloat(@NonNull String key); float getFloat(@NonNull String key, float defaultValue); void put(@NonNull String key, boolean value); boolean getBoolean(@NonNull String key); boolean getBoolean(@NonNull String key, boolean defaultValue); void put(@NonNull String key, @NonNull Set<String> values); Set<String> getStringSet(@NonNull String key); Set<String> getStringSet(@NonNull String key, @NonNull Set<String> defaultValue); Map<String, ?> getAll(); boolean contains(@NonNull String key); void remove(@NonNull String key); void clear(); }### Answer: @Test public void getBoolean() throws Exception { Assert.assertTrue(spUtils1.getBoolean("booleanKey1")); Assert.assertTrue(spUtils1.getBoolean("booleanKey", true)); Assert.assertFalse(spUtils1.getBoolean("booleanKey")); Assert.assertTrue(spUtils2.getBoolean("booleanKey2")); Assert.assertTrue(spUtils2.getBoolean("booleanKey", true)); Assert.assertFalse(spUtils2.getBoolean("booleanKey")); }
### Question: SPUtils { public Map<String, ?> getAll() { return sp.getAll(); } private SPUtils(String spName); static SPUtils getInstance(); static SPUtils getInstance(String spName); void put(@NonNull String key, @NonNull String value); String getString(@NonNull String key); String getString(@NonNull String key, @NonNull String defaultValue); void put(@NonNull String key, int value); int getInt(@NonNull String key); int getInt(@NonNull String key, int defaultValue); void put(@NonNull String key, long value); long getLong(@NonNull String key); long getLong(@NonNull String key, long defaultValue); void put(@NonNull String key, float value); float getFloat(@NonNull String key); float getFloat(@NonNull String key, float defaultValue); void put(@NonNull String key, boolean value); boolean getBoolean(@NonNull String key); boolean getBoolean(@NonNull String key, boolean defaultValue); void put(@NonNull String key, @NonNull Set<String> values); Set<String> getStringSet(@NonNull String key); Set<String> getStringSet(@NonNull String key, @NonNull Set<String> defaultValue); Map<String, ?> getAll(); boolean contains(@NonNull String key); void remove(@NonNull String key); void clear(); }### Answer: @Test public void getAll() throws Exception { Map<String, ?> map; System.out.println("sp1 {"); map = spUtils1.getAll(); for (Map.Entry<String, ?> entry : map.entrySet()) { System.out.println(" " + entry.getKey() + ": " + entry.getValue()); } System.out.println("}"); System.out.println("sp2 {"); map = spUtils2.getAll(); for (Map.Entry<String, ?> entry : map.entrySet()) { System.out.println(" " + entry.getKey() + ": " + entry.getValue()); } System.out.println("}"); }
### Question: SPUtils { public void remove(@NonNull String key) { sp.edit().remove(key).apply(); } private SPUtils(String spName); static SPUtils getInstance(); static SPUtils getInstance(String spName); void put(@NonNull String key, @NonNull String value); String getString(@NonNull String key); String getString(@NonNull String key, @NonNull String defaultValue); void put(@NonNull String key, int value); int getInt(@NonNull String key); int getInt(@NonNull String key, int defaultValue); void put(@NonNull String key, long value); long getLong(@NonNull String key); long getLong(@NonNull String key, long defaultValue); void put(@NonNull String key, float value); float getFloat(@NonNull String key); float getFloat(@NonNull String key, float defaultValue); void put(@NonNull String key, boolean value); boolean getBoolean(@NonNull String key); boolean getBoolean(@NonNull String key, boolean defaultValue); void put(@NonNull String key, @NonNull Set<String> values); Set<String> getStringSet(@NonNull String key); Set<String> getStringSet(@NonNull String key, @NonNull Set<String> defaultValue); Map<String, ?> getAll(); boolean contains(@NonNull String key); void remove(@NonNull String key); void clear(); }### Answer: @Test public void testRemove() throws Exception { Assert.assertEquals("stringVal1", spUtils1.getString("stringKey1")); spUtils1.remove("stringKey1"); Assert.assertEquals("", spUtils1.getString("stringKey1")); Assert.assertEquals("stringVal2", spUtils2.getString("stringKey2")); spUtils2.remove("stringKey2"); Assert.assertEquals("", spUtils2.getString("stringKey2")); }
### Question: SPUtils { public boolean contains(@NonNull String key) { return sp.contains(key); } private SPUtils(String spName); static SPUtils getInstance(); static SPUtils getInstance(String spName); void put(@NonNull String key, @NonNull String value); String getString(@NonNull String key); String getString(@NonNull String key, @NonNull String defaultValue); void put(@NonNull String key, int value); int getInt(@NonNull String key); int getInt(@NonNull String key, int defaultValue); void put(@NonNull String key, long value); long getLong(@NonNull String key); long getLong(@NonNull String key, long defaultValue); void put(@NonNull String key, float value); float getFloat(@NonNull String key); float getFloat(@NonNull String key, float defaultValue); void put(@NonNull String key, boolean value); boolean getBoolean(@NonNull String key); boolean getBoolean(@NonNull String key, boolean defaultValue); void put(@NonNull String key, @NonNull Set<String> values); Set<String> getStringSet(@NonNull String key); Set<String> getStringSet(@NonNull String key, @NonNull Set<String> defaultValue); Map<String, ?> getAll(); boolean contains(@NonNull String key); void remove(@NonNull String key); void clear(); }### Answer: @Test public void testContains() throws Exception { Assert.assertTrue(spUtils1.contains("stringKey1")); Assert.assertFalse(spUtils1.contains("stringKey")); Assert.assertTrue(spUtils2.contains("stringKey2")); Assert.assertFalse(spUtils2.contains("stringKey")); }
### Question: SPUtils { public void clear() { sp.edit().clear().apply(); } private SPUtils(String spName); static SPUtils getInstance(); static SPUtils getInstance(String spName); void put(@NonNull String key, @NonNull String value); String getString(@NonNull String key); String getString(@NonNull String key, @NonNull String defaultValue); void put(@NonNull String key, int value); int getInt(@NonNull String key); int getInt(@NonNull String key, int defaultValue); void put(@NonNull String key, long value); long getLong(@NonNull String key); long getLong(@NonNull String key, long defaultValue); void put(@NonNull String key, float value); float getFloat(@NonNull String key); float getFloat(@NonNull String key, float defaultValue); void put(@NonNull String key, boolean value); boolean getBoolean(@NonNull String key); boolean getBoolean(@NonNull String key, boolean defaultValue); void put(@NonNull String key, @NonNull Set<String> values); Set<String> getStringSet(@NonNull String key); Set<String> getStringSet(@NonNull String key, @NonNull Set<String> defaultValue); Map<String, ?> getAll(); boolean contains(@NonNull String key); void remove(@NonNull String key); void clear(); }### Answer: @Test public void clear() throws Exception { spUtils1.clear(); Assert.assertEquals("", spUtils1.getString("stringKey1")); Assert.assertEquals(-1, spUtils1.getInt("intKey1")); Assert.assertEquals(-1L, spUtils1.getLong("longKey1")); Assert.assertEquals(-1f, spUtils1.getFloat("floatKey1"), 0f); Assert.assertFalse(spUtils1.getBoolean("booleanKey1")); spUtils2.clear(); Assert.assertEquals("", spUtils2.getString("stringKey2")); Assert.assertEquals(-1, spUtils2.getInt("intKey2")); Assert.assertEquals(-1L, spUtils2.getLong("longKey1")); Assert.assertEquals(-1f, spUtils2.getFloat("floatKey1"), 0f); Assert.assertFalse(spUtils2.getBoolean("booleanKey1")); }
### Question: ProxyConfig { public String getProxyHost() { return proxyHost; } ProxyConfig(PropertyLoader propertyLoader); boolean isProxyRequired(); String getProxyType(); String getProxyHost(); int getProxyPort(); String getProxyAddress(); String getProxyUsername(); String getProxyPassword(); String getNonProxyHosts(); }### Answer: @Test public void proxySettingsObtainedInOrder() { Properties properties = givenDefaultProperties(); environmentVariables.set("HTTP_PROXY", "http: ProxyConfig proxyConfig = new ProxyConfig(new DefaultPropertyLoader(properties)); assertThat(proxyConfig.getProxyHost(), is("proxyhost3")); System.setProperty("http.proxyHost", "proxyhost2"); proxyConfig = new ProxyConfig(new DefaultPropertyLoader(properties)); assertThat(proxyConfig.getProxyHost(), is("proxyhost2")); given(properties.getProperty("proxy.host")).willReturn("proxyhost1"); proxyConfig = new ProxyConfig(new DefaultPropertyLoader(properties)); assertThat(proxyConfig.getProxyHost(), is("proxyhost1")); }
### Question: ConcordionBrowserFixture extends ConcordionFixture implements BrowserBasedTest { @Override public Browser getBrowser() { return getBrowser(threadBrowserId.get()); } static void setScreenshotTakerClass(Class<? extends ScreenshotTaker> screenshotTaker); @Override Browser getBrowser(); Browser getBrowser(String key); Browser getBrowser(String key, BrowserProvider browserProvider); void switchBrowser(String key); void switchBrowser(String key, BrowserProvider browserProvider); @AfterSuite void resetThreadBrowsers(); }### Answer: @Test public void closesMultipleDriversForSingleBrowserProvider() throws IOException { BrowserProvider mockProvider = mock(BrowserProvider.class); WebDriver mockDriver = mock(WebDriver.class); when(mockProvider.createDriver()).thenReturn(mockDriver); Browser browser1 = test1.getBrowser("A", mockProvider); browser1.getDriver(); Browser browser2 = test1.getBrowser("B", mockProvider); browser2.getDriver(); test1.closeSuiteResources(); verify(mockProvider, times(1)).close(); verify(mockDriver, times(2)).quit(); } @Test public void closesMultipleDriversAndBrowserProviders() throws IOException { BrowserProvider mockProvider1 = mock(BrowserProvider.class); WebDriver mockDriver1 = mock(WebDriver.class); when(mockProvider1.createDriver()).thenReturn(mockDriver1); BrowserProvider mockProvider2 = mock(BrowserProvider.class); WebDriver mockDriver2 = mock(WebDriver.class); when(mockProvider2.createDriver()).thenReturn(mockDriver2); Browser browser1 = test1.getBrowser("E", mockProvider1); browser1.getDriver(); Browser browser2 = test1.getBrowser("F", mockProvider1); browser2.getDriver(); Browser browser3 = test1.getBrowser("G", mockProvider2); browser3.getDriver(); test1.closeSuiteResources(); verify(mockProvider1, times(1)).close(); verify(mockDriver1, times(2)).quit(); verify(mockProvider2, times(1)).close(); verify(mockDriver2, times(1)).quit(); } @Test public void runningTestsAsSeparateSuites_browsersAreNotReused() { BrowserProvider mockProvider = mock(BrowserProvider.class); ConcordionBrowserFixture test = this.test1; Browser browser1 = test.getBrowser("X", mockProvider); afterSuite(test); ConcordionBrowserFixture test2 = new ConcordionBrowserFixture() {}; Browser browser2 = test2.getBrowser("X", mockProvider); afterSuite(test2); assertThat(browser1, is(not(browser2))); } @Test public void reusesBrowsersForSameKey() { BrowserProvider mockProvider = mock(BrowserProvider.class); Browser browser1 = test1.getBrowser("X", mockProvider); Browser browser2 = test1.getBrowser("X", mockProvider); assertThat(browser1, is(browser2)); }
### Question: PageHelper { public <P extends BasePageObject<P>> P newInstance(Class<P> expectedPage, Object... params) { try { if (params.length > 0) { Class<?>[] constructorArguments = new Class<?>[2]; constructorArguments[0] = BrowserBasedTest.class; constructorArguments[1] = Object[].class; return expectedPage.getDeclaredConstructor(constructorArguments).newInstance(getTest(), params); } else { return expectedPage.getDeclaredConstructor(BrowserBasedTest.class).newInstance(getTest()); } } catch (InstantiationException \| IllegalAccessException \| IllegalArgumentException \| InvocationTargetException \| NoSuchMethodException \| SecurityException e) { if (e.getMessage() == null && e.getCause() != null) { throw new RuntimeException(e.getCause()); } else { throw new RuntimeException(e); } } } PageHelper(BasePageObject<?> pageObject); PageHelper(BasePageObject<?> pageObject, Class<?> logLocation); void triggerCheckPage(WebElement triggerElement, String tag); void checkWindow(String tag); void checkRegion(WebElement region, String tag); boolean isElementPresent(WebElement element); boolean isElementVisible(WebElement element); static boolean isElementPresent(WebDriver driver, By by); static boolean isElementVisible(WebDriver driver, By by); void capturePage(WebElement element); void capturePage(WebElement element, String description); void capturePage(ScreenshotTaker screenshotTaker, String description); void capturePage(WebElement element, String description, CardResult result); P capturePageAndClick(WebElement element, Class<P> expectedPage, Object... params); P capturePageAndClick(WebElement element, String description, Class<P> expectedPage, Object... params); P capturePageAndClick(WebElement element, int timeoutSeconds, String description, Class<P> expectedPage, Object... params); void waitForElementToClickable(WebElement webElement, int timeOutInSeconds); P newInstance(Class<P> expectedPage, Object... params); WebElement getFirstVisibleElement(List<WebElement> webElements); String getCurrentFrameNameOrId(); static String getCurrentFrameNameOrId(WebDriver driver); static WebElement getCurrentFrame(WebDriver driver); void switchToMainDocument(); static void switchToMainDocument(WebDriver driver); void acceptAlertIfPresent(); static void acceptAlertIfPresent(WebDriver driver); static void waitUntil(WebDriver driver, ExpectedCondition<?> condition, int timeOutInSeconds); }### Answer: @Test public void canCreateInstanceOfPageObjectUsingBBTOnly() { PageHelper tpo = setUpMocks(); TestPageObject testPageObject = tpo.newInstance(TestPageObject.class); assertNotNull("Should not be null when constructing instance of " + TestPageObject.class.getName(), testPageObject); } @Test public void canCreateInstanceOfPageObjectUsingBBTPlusMultipleParams() { PageHelper tpo = setUpMocks(); TestPageObject testPageObject = tpo.newInstance(TestPageObject.class, "HelloWorld", 1); assertNotNull("Should not be null when constructing instance of " + TestPageObject.class.getName() + " and optional parameters", testPageObject); } @Test public void shouldFailAsNoParamsConstructorForPageObject() { PageHelper tpo = setUpMocks(); thrown.expect(RuntimeException.class); thrown.expectCause(allOf( instanceOf(NoSuchMethodException.class), hasProperty("message", is("org.concordion.cubano.driver.web.TestPageObjectNoParams.<init>(org.concordion.cubano.driver.BrowserBasedTest, [Ljava.lang.Object;)")))); tpo.newInstance(TestPageObjectNoParams.class, "ShouldFailAsNoParamsConstructor"); } @Test public void canCreateInstanceOfPageObjectWhichOnlyHasBBTConstructor() { PageHelper tpo = setUpMocks(); TestPageObjectNoParams testPageObjectNoParams = tpo.newInstance(TestPageObjectNoParams.class); assertNotNull("Should not be null when constructing instance of " + TestPageObjectNoParams.class.getName() + " and class has Browser Based Test Constructor Only", testPageObjectNoParams); }
### Question: CaselessProperties extends Properties { @Override public synchronized Object put(Object key, Object value) { lookup.put(((String) key), (String) key); return super.put(key, value); } @Override synchronized Object put(Object key, Object value); @Override String getProperty(String key); @Override String getProperty(String key, String defaultValue); }### Answer: @Test public void propertyKeyOriginalCaseIsAvailalbe() { Properties properties = new CaselessProperties(); properties.put("a.SETTING", "value"); @SuppressWarnings("unchecked") Enumeration<String> en = (Enumeration<String>) properties.propertyNames(); String propName = en.nextElement(); assertThat(propName, is("a.SETTING")); }
### Question: DefaultPropertyLoader implements PropertyLoader { @Override public String getProperty(String key) { String value = retrieveProperty(key); if (value.isEmpty()) { throw new IllegalArgumentException(String.format("Unable to find property %s", key)); } return value; } DefaultPropertyLoader(Properties properties); String getEnvironment(); @Override String getProperty(String key); @Override String getProperty(String key, String defaultValue); @Override boolean getPropertyAsBoolean(String key, String defaultValue); @Override int getPropertyAsInteger(String key, String defaultValue); @Override Map<String, String> getPropertiesStartingWith(String keyPrefix); @Override Map<String, String> getPropertiesStartingWith(String keyPrefix, boolean trimPrefix); }### Answer: @Test public void environmentPropertiesOverrideDefaultProperties() { Properties properties = givenDefaultProperties(); given(properties.getProperty("a.setting")).willReturn("false"); given(properties.getProperty("SIT.a.setting")).willReturn("true"); DefaultPropertyLoader loader = new DefaultPropertyLoader(properties); assertThat(loader.getProperty("a.setting"), is("false")); given(properties.getProperty(eq("environment"), any())).willReturn("SIT"); loader = new DefaultPropertyLoader(properties); assertThat(loader.getProperty("a.setting"), is("true")); }
### Question: DefaultPropertyLoader implements PropertyLoader { public String getEnvironment() { return environment; } DefaultPropertyLoader(Properties properties); String getEnvironment(); @Override String getProperty(String key); @Override String getProperty(String key, String defaultValue); @Override boolean getPropertyAsBoolean(String key, String defaultValue); @Override int getPropertyAsInteger(String key, String defaultValue); @Override Map<String, String> getPropertiesStartingWith(String keyPrefix); @Override Map<String, String> getPropertiesStartingWith(String keyPrefix, boolean trimPrefix); }### Answer: @Test public void systemPropertyWillOverrideEnvironment() throws Exception { Properties properties = givenDefaultProperties(); System.setProperty("environment", "SIT"); DefaultPropertyLoader loader = new DefaultPropertyLoader(properties); assertThat(loader.getEnvironment(), is("SIT")); }
### Question: DefaultPropertyLoader implements PropertyLoader { @Override public Map<String, String> getPropertiesStartingWith(String keyPrefix) { return getPropertiesStartingWith(keyPrefix, false); } DefaultPropertyLoader(Properties properties); String getEnvironment(); @Override String getProperty(String key); @Override String getProperty(String key, String defaultValue); @Override boolean getPropertyAsBoolean(String key, String defaultValue); @Override int getPropertyAsInteger(String key, String defaultValue); @Override Map<String, String> getPropertiesStartingWith(String keyPrefix); @Override Map<String, String> getPropertiesStartingWith(String keyPrefix, boolean trimPrefix); }### Answer: @Test public void canSearchForPopertiesWithPrefixMatchingCase() throws IOException { Properties properties = givenDefaultSearchProperties(); DefaultPropertyLoader loader = new DefaultPropertyLoader(properties); Map<String, String> found = loader.getPropertiesStartingWith("a.setting."); assertThat(found.values().size(), is(1)); assertThat(found.keySet().iterator().next(), is("a.setting.2")); } @Test public void canSearchForPopertiesAngGetOriginalPropertyCase() throws IOException { Properties properties = givenDefaultSearchProperties(); DefaultPropertyLoader loader = new DefaultPropertyLoader(properties); Map<String, String> found = loader.getPropertiesStartingWith("a."); assertThat(found.values().size(), is(2)); assertThat(found.keySet().iterator().next(), is("a.SETTING.1")); } @Test public void canSearchForPopertiesAngGetKeysWithoutPrefix() throws IOException { Properties properties = givenDefaultSearchProperties(); DefaultPropertyLoader loader = new DefaultPropertyLoader(properties); Map<String, String> found = loader.getPropertiesStartingWith("a.setting.", true); assertThat(found.values().size(), is(1)); assertThat(found.keySet().iterator().next(), is("2")); }
### Question: DefaultPropertiesLoader implements PropertiesLoader { @Override public Properties getProperties() { return properties; } protected DefaultPropertiesLoader(String properties, String userProperties); private DefaultPropertiesLoader(); static DefaultPropertiesLoader getInstance(); @Override Properties getProperties(); }### Answer: @Test public void userPropertiesOverrideConfigProperties() { String defaultProperties = "a.setting=false"; String userProperties = "a.setting=true"; Properties properties = new DefaultPropertiesLoader(defaultProperties, "").getProperties(); assertThat(properties.getProperty("a.setting"), is("false")); properties = new DefaultPropertiesLoader(defaultProperties, userProperties).getProperties(); assertThat(properties.getProperty("a.setting"), is("true")); }
### Question: ConcordionBase implements ResourceRegistry { @Override public boolean isRegistered(Closeable resource, ResourceScope scope) { return getResourcePairFromScope(resource, scope).isPresent(); } @Override void registerCloseableResource(Closeable resource, ResourceScope scope); @Override void registerCloseableResource(Closeable resource, ResourceScope scope, CloseListener listener); @Override boolean isRegistered(Closeable resource, ResourceScope scope); @Override void closeResource(Closeable resource); }### Answer: @Test public void isRegisteredReturnsFalseIfNotRegistered() { assertFalse(test1.isRegistered(resource0, ResourceScope.SPECIFICATION)); }
### Question: PrometheusMetricsReporter extends AbstractMetricsReporter implements MetricsReporter { @Override public void reportSpan(SpanData spanData) { String[] labelValues = getLabelValues(spanData); if (labelValues != null) { this.histogram.labels(labelValues).observe(spanData.getDuration() / (double)1000000); } } private PrometheusMetricsReporter(String name, CollectorRegistry registry, List<MetricLabel> labels); @Override void reportSpan(SpanData spanData); static Builder newMetricsReporter(); }### Answer: @Test public void testReportSpan() { PrometheusMetricsReporter reporter = PrometheusMetricsReporter.newMetricsReporter() .withCollectorRegistry(collectorRegistry) .withConstLabel("span.kind", Tags.SPAN_KIND_CLIENT) .build(); Map<String,Object> spanTags = new HashMap<String,Object>(); spanTags.put(Tags.SPAN_KIND.getKey(), Tags.SPAN_KIND_CLIENT); SpanData spanData = mock(SpanData.class); when(spanData.getOperationName()).thenReturn("testop"); when(spanData.getTags()).thenReturn(spanTags); when(spanData.getDuration()).thenReturn(100000L); reporter.reportSpan(spanData); List<MetricFamilySamples> samples = reporter.getHistogram().collect(); assertEquals(1, samples.size()); assertEquals(17, samples.get(0).samples.size()); for (int i=0; i < samples.get(0).samples.size(); i++) { Sample sample = samples.get(0).samples.get(i); assertEquals("testop", sample.labelValues.get(0)); List<String> labelNames = new ArrayList<String>(sample.labelNames); if (labelNames.get(labelNames.size()-1).equals("le")) { labelNames.remove(labelNames.size()-1); if (sample.labelValues.get(sample.labelNames.size()-1).equals("+Inf")) { assertEquals(1, (int)sample.value); } } assertEquals(Arrays.asList(reporter.getLabelNames()), labelNames); } }
### Question: MicrometerMetricsReporter extends AbstractMetricsReporter implements MetricsReporter { @Override public void reportSpan(SpanData spanData) { boolean skip = Arrays.stream(this.metricLabels).anyMatch(m -> m.value(spanData) == null); if (skip) { return; } List<Tag> tags = Arrays.stream(this.metricLabels) .map(m -> new ImmutableTag(m.name(), m.value(spanData).toString())) .collect(Collectors.toList()); Timer timer = this.registry.find(this.name).tags(tags).timer(); if (null != timer) { timer.record(spanData.getDuration(), TimeUnit.MICROSECONDS); return; } Timer.Builder builder = Timer.builder(this.name).tags(tags); if (publishPercentileHistogram) { builder.publishPercentileHistogram(); } if (null != percentiles) { builder.publishPercentiles(percentiles); } if (null != sla) { builder.sla(sla); } if (null != minimumExpectedValue) { builder.minimumExpectedValue(minimumExpectedValue); } if (null != maximumExpectedValue) { builder.maximumExpectedValue(maximumExpectedValue); } builder.register(this.registry).record(spanData.getDuration(), TimeUnit.MICROSECONDS); } protected MicrometerMetricsReporter(String name, List<MetricLabel> labels, MeterRegistry registry, Duration sla, Duration minimumExpectedValue, Duration maximumExpectedValue, boolean publishPercentileHistogram, double... percentiles); @Override void reportSpan(SpanData spanData); static Builder newMetricsReporter(); }### Answer: @Test public void testReportSpan() { SpanData spanData = defaultMockSpanData(); when(spanData.getTags()).thenReturn(Collections.singletonMap(Tags.SPAN_KIND.getKey(), Tags.SPAN_KIND_CLIENT)); MicrometerMetricsReporter reporter = MicrometerMetricsReporter.newMetricsReporter() .withConstLabel("span.kind", Tags.SPAN_KIND_CLIENT) .build(); reporter.reportSpan(spanData); List<Tag> tags = defaultTags(); assertEquals(100, (long) registry.find("span").timer().totalTime(TimeUnit.MILLISECONDS)); assertEquals(1, Metrics.timer("span", tags).count()); }
### Question: PrometheusMetricsReporter extends AbstractMetricsReporter implements MetricsReporter { protected static String convertLabel(String label) { StringBuilder builder = new StringBuilder(label); for (int i=0; i < builder.length(); i++) { char ch = builder.charAt(i); if (!(ch == '_' \|\| ch == ':' \|\| Character.isLetter(ch) \|\| (i > 0 && Character.isDigit(ch)))) { builder.setCharAt(i, '_'); } } return builder.toString(); } private PrometheusMetricsReporter(String name, CollectorRegistry registry, List<MetricLabel> labels); @Override void reportSpan(SpanData spanData); static Builder newMetricsReporter(); }### Answer: @Test public void testConvertLabel() { assertEquals("Hello9", PrometheusMetricsReporter.convertLabel("Hello9")); assertEquals("Hello_there", PrometheusMetricsReporter.convertLabel("Hello there")); assertEquals("_tag1", PrometheusMetricsReporter.convertLabel("1tag1")); assertEquals("tag_:_", PrometheusMetricsReporter.convertLabel("tag£:%")); }
### Question: TagMetricLabel implements MetricLabel { @Override public Object value(SpanData spanData) { Object ret = spanData.getTags().get(name()); return ret == null ? defaultValue : ret; } TagMetricLabel(String name, Object defaultValue); @Override String name(); @Override Object defaultValue(); @Override Object value(SpanData spanData); }### Answer: @Test public void testLabelFromTagWithValue() { MetricLabel label = new TagMetricLabel(TEST_LABEL, TEST_LABEL_DEFAULT); Map<String,Object> tags = new HashMap<String,Object>(); tags.put(TEST_LABEL, "TagValue"); SpanData spanData = mock(SpanData.class); when(spanData.getTags()).thenReturn(tags); assertEquals("TagValue", label.value(spanData)); } @Test public void testLabelFromTagWithNull() { MetricLabel label = new TagMetricLabel(TEST_LABEL, TEST_LABEL_DEFAULT); Map<String,Object> tags = new HashMap<String,Object>(); tags.put(TEST_LABEL, null); SpanData spanData = mock(SpanData.class); when(spanData.getTags()).thenReturn(tags); assertEquals(TEST_LABEL_DEFAULT, label.value(spanData)); }
### Question: BaggageMetricLabel implements MetricLabel { @Override public Object value(SpanData spanData) { Object ret = spanData.getBaggageItem(name()); return ret == null ? defaultValue : ret; } BaggageMetricLabel(String name, Object defaultValue); @Override String name(); @Override Object defaultValue(); @Override Object value(SpanData spanData); }### Answer: @Test public void testLabelFromBaggage() { MetricLabel label = new BaggageMetricLabel(TEST_LABEL, TEST_LABEL_DEFAULT); SpanData spanData = mock(SpanData.class); when(spanData.getBaggageItem(anyString())).thenReturn("BaggageValue"); assertEquals("BaggageValue", label.value(spanData)); verify(spanData, times(1)).getBaggageItem(TEST_LABEL); }
### Question: AbstractMetricsReporter implements MetricsReporter { protected String[] getLabelValues(SpanData spanData) { String[] values = new String[metricLabels.length]; for (int i=0; i < values.length; i++) { Object value = metricLabels[i].value(spanData); if (value == null) { return null; } values[i] = value.toString(); } return values; } protected AbstractMetricsReporter(List<MetricLabel> labels); }### Answer: @Test public void testWithSpecifiedTagValues() { AbstractMetricsReporter reporter = new AbstractMetricsReporter( Collections.<MetricLabel>emptyList()) { @Override public void reportSpan(SpanData spanData) { } }; Map<String,Object> spanTags = new HashMap<String,Object>(); spanTags.put(Tags.SPAN_KIND.getKey(), Tags.SPAN_KIND_SERVER); spanTags.put(Tags.ERROR.getKey(), true); SpanData spanData = mock(SpanData.class); when(spanData.getOperationName()).thenReturn("testop"); when(spanData.getTags()).thenReturn(spanTags); String[] labelValues = reporter.getLabelValues(spanData); assertEquals(3, labelValues.length); assertEquals(Tags.SPAN_KIND_SERVER, labelValues[1]); assertEquals(Boolean.toString(true), labelValues[2]); } @Test public void testWithSpecifiedOverriddenTagValue() { MetricLabel errorMetricTag = new MetricLabel() { @Override public String name() { return Tags.ERROR.getKey(); } @Override public Object defaultValue() { return null; } @Override public Object value(SpanData spanData) { Object error = spanData.getTags().containsKey(name()) ? spanData.getTags().get(name()) : false; if (spanData.getTags().containsKey(Tags.HTTP_STATUS.getKey())) { int status = (int)spanData.getTags().get(Tags.HTTP_STATUS.getKey()); if (status > 400) { error = "4xx"; } else if (status > 500) { error = "5xx"; } } return error; } }; AbstractMetricsReporter reporter = new AbstractMetricsReporter( Arrays.<MetricLabel>asList(new ConstMetricLabel("service", "TestService"), errorMetricTag)) { @Override public void reportSpan(SpanData spanData) { } }; Map<String,Object> spanTags = new HashMap<String,Object>(); spanTags.put(Tags.ERROR.getKey(), true); spanTags.put(Tags.HTTP_STATUS.getKey(), 401); spanTags.put(Tags.SPAN_KIND.getKey(), Tags.SPAN_KIND_CLIENT); SpanData spanData = mock(SpanData.class); when(spanData.getOperationName()).thenReturn("testop"); when(spanData.getTags()).thenReturn(spanTags); String[] labelValues = reporter.getLabelValues(spanData); assertEquals(4, labelValues.length); assertEquals("TestService", labelValues[0]); assertEquals("testop", labelValues[1]); assertEquals(Tags.SPAN_KIND_CLIENT, labelValues[2]); assertEquals("4xx", labelValues[3]); }
### Question: NumberPadTimePickerPresenter implements INumberPadTimePicker.Presenter, DigitwiseTimeModel.OnInputChangeListener { @Override public void presentState(@NonNull INumberPadTimePicker.State state) { initialize(state); if (!mIs24HourMode) { mView.setAmPmDisplayIndex(mLocaleModel.isAmPmWrittenBeforeTime() ? 0 : 1); final CharSequence amPmDisplayText; switch (state.getAmPmState()) { case AM: amPmDisplayText = mAltTexts[0]; break; case PM: amPmDisplayText = mAltTexts[1]; break; default: amPmDisplayText = null; break; } mView.updateAmPmDisplay(amPmDisplayText); } mView.setAmPmDisplayVisible(!mIs24HourMode); setAltKeysTexts(); updateViewEnabledStates(); } NumberPadTimePickerPresenter(@NonNull INumberPadTimePicker.View view, @NonNull LocaleModel localeModel, boolean is24HourMode); @Override void onNumberKeyClick(CharSequence numberKeyText); @Override void onAltKeyClick(CharSequence altKeyText); @Override void onBackspaceClick(); @Override boolean onBackspaceLongClick(); @Override boolean onOkButtonClick(); @Override void onShow(); @Override void onSetOkButtonCallbacks(); @Override void presentState(@NonNull INumberPadTimePicker.State state); @Override void detachView(); @Override INumberPadTimePicker.State getState(); @Override void onDigitStored(int digit); @Override void onDigitRemoved(int digit); @Override void onDigitsCleared(); }### Answer: @Test public void verifyViewEnabledStatesForEmptyState() { createNewViewAndPresenter(MODE_12HR); mPresenters[MODE_12HR].presentState(NumberPadTimePickerState.EMPTY); verifyInitialization(MODE_12HR); verify(mViews[MODE_12HR]).setOkButtonEnabled(false); createNewViewAndPresenter(MODE_24HR); mPresenters[MODE_24HR].presentState(NumberPadTimePickerState.EMPTY); verifyInitialization(MODE_24HR); verify(mViews[MODE_24HR]).setOkButtonEnabled(false); }
### Question: NumberPadTimePickerPresenter implements INumberPadTimePicker.Presenter, DigitwiseTimeModel.OnInputChangeListener { @Override public void onAltKeyClick(CharSequence altKeyText) { final String altKeyString = altKeyText.toString(); final int[] altDigits = mTextModel.altDigits(altKeyString); if (count() <= 2) { insertDigits(altDigits); } if (!is24HourFormat()) { mAmPmState = altKeyString.equalsIgnoreCase(mAltTexts[0]) ? AM : PM; mView.updateAmPmDisplay(altKeyString); } else { mAmPmState = HRS_24; } updateViewEnabledStates(); } NumberPadTimePickerPresenter(@NonNull INumberPadTimePicker.View view, @NonNull LocaleModel localeModel, boolean is24HourMode); @Override void onNumberKeyClick(CharSequence numberKeyText); @Override void onAltKeyClick(CharSequence altKeyText); @Override void onBackspaceClick(); @Override boolean onBackspaceLongClick(); @Override boolean onOkButtonClick(); @Override void onShow(); @Override void onSetOkButtonCallbacks(); @Override void presentState(@NonNull INumberPadTimePicker.State state); @Override void detachView(); @Override INumberPadTimePicker.State getState(); @Override void onDigitStored(int digit); @Override void onDigitRemoved(int digit); @Override void onDigitsCleared(); }### Answer: @Test public void mode12Hr_VerifyOnTimeSetCallback() { for (int time = 100; time <= 1259; time++) { if (time % 100 > 59) { System.out.println("Skipping invalid time " + time); continue; } System.out.println("Testing time " + time); for (int amOrPm = 0; amOrPm < 2; amOrPm++) { createNewViewAndPresenter(MODE_12HR); if (time <= 959) { inputThreeDigitTime(time, MODE_12HR); } else { inputFourDigitTime(time, MODE_12HR); } mPresenters[MODE_12HR].onAltKeyClick(altText(amOrPm, MODE_12HR)); final int hour = (time >= 1200 ? 0 : time / 100) + (amOrPm == 1 ? 12 : 0); final int minute = time % 100; confirmTimeSelection(mPresenters[MODE_12HR], MODE_12HR, hour, minute); } } }
### Question: InsertOrReplaceProxy implements MethodInterceptor { @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { if (method.getName().equals("toString") && args.length == 0) { String sql = toString((String) proxy.invoke(realInsert, args)); return sql; } return proxy.invoke(realInsert, args); } Insert getInstance(Class<Insert> clazz, Insert realInsert); @Override Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy); String toString(String sql); }### Answer: @Test public void intercept() throws Exception { String sql = "INSERT INTO person (id, name) VALUES (1, 'KK')"; CCJSqlParserManager pm = new CCJSqlParserManager(); Insert insert = (Insert) pm.parse(new StringReader(sql)); Insert insertProxy = new InsertOrReplaceProxy().getInstance(Insert.class, insert); Table table = insertProxy.getTable(); Assert.assertEquals("person", table.getName()); String string = insertProxy.toString(); Assert.assertEquals("INSERT OR REPLACE INTO person (id, name) VALUES (1, 'KK')", string); }
### Question: ShadowResources { public String getString(@StringRes int id) throws NotFoundException { return getText(id).toString(); } ShadowResources(); String getString(@StringRes int id); @NonNull String[] getStringArray(@ArrayRes int id); @NonNull int[] getIntArray(@ArrayRes int id); String getPackageName(); }### Answer: @Test public void getString() throws Exception { Assert.assertEquals("KBUnitTest", resources.getString(R.string.test_string)); }
### Question: ShadowResources { @NonNull public String[] getStringArray(@ArrayRes int id) throws NotFoundException { Map<Integer, String> idNameMap = getArrayIdTable(); Map<String, List<String>> stringArrayMap = getResourceStringArrayMap(); if (idNameMap.containsKey(id)) { String name = idNameMap.get(id); if (stringArrayMap.containsKey(name)) { List<String> stringList = stringArrayMap.get(name); return stringList.toArray(new String[0]); } } throw new Resources.NotFoundException("String array resource ID #0x" + Integer.toHexString(id)); } ShadowResources(); String getString(@StringRes int id); @NonNull String[] getStringArray(@ArrayRes int id); @NonNull int[] getIntArray(@ArrayRes int id); String getPackageName(); }### Answer: @Test public void getStringArray() throws Exception { String[] array = resources.getStringArray(R.array.arrayName); Assert.assertEquals("item0", array[0]); Assert.assertEquals("item1", array[1]); }
### Question: ShadowResources { @NonNull public int[] getIntArray(@ArrayRes int id) throws NotFoundException { Map<Integer, String> idNameMap = getArrayIdTable(); Map<String, List<Integer>> intArrayMap = getResourceIntArrayMap(); if (idNameMap.containsKey(id)) { String name = idNameMap.get(id); if (intArrayMap.containsKey(name)) { List<Integer> intList = intArrayMap.get(name); int[] intArray = new int[intList.size()]; for (int i = 0; i < intList.size(); i++) { intArray[i] = intList.get(i); } return intArray; } } return new int[0]; } ShadowResources(); String getString(@StringRes int id); @NonNull String[] getStringArray(@ArrayRes int id); @NonNull int[] getIntArray(@ArrayRes int id); String getPackageName(); }### Answer: @Test public void getIntArray() { int[] intArray = resources.getIntArray(R.array.intArray); Assert.assertEquals(0, intArray[0]); Assert.assertEquals(1, intArray[1]); int[] intArrayNoItem = resources.getIntArray(R.array.intArrayNoItem); Assert.assertEquals(0, intArrayNoItem.length); }
### Question: ShadowResources { public String getPackageName() { if (!TextUtils.isEmpty(mPackageName)) { return mPackageName; } String manifestPath = "build/intermediates/bundles/debug/AndroidManifest.xml"; if (!new File(manifestPath).exists()) { manifestPath = "build/intermediates/bundles/release/AndroidManifest.xml"; } FileReader reader = new FileReader(); if (new File(manifestPath).exists()) { String manifest = reader.readString(manifestPath); Element body = Jsoup.parse(manifest).body(); String packageName = body.childNode(0).attr("package"); return mPackageName = packageName; } else { manifestPath = "build/intermediates/manifest/androidTest/debug/AndroidManifest.xml"; String manifest = reader.readString(manifestPath); Element body = Jsoup.parse(manifest).body(); String packageName = body.childNode(0).attr("package"); packageName = packageName.substring(0, packageName.length() - ".test".length()); return mPackageName = packageName; } } ShadowResources(); String getString(@StringRes int id); @NonNull String[] getStringArray(@ArrayRes int id); @NonNull int[] getIntArray(@ArrayRes int id); String getPackageName(); }### Answer: @Test public void getPackageName() throws Exception { Assert.assertEquals("net.kb.test.library", resources.getPackageName()); }
### Question: KbSqlParserManager { public Statement parse(String sql) throws JSQLParserException { sql = sql.trim(); boolean isInsertOrReplace = false; if (sql.toUpperCase().startsWith("INSERT OR REPLACE")) { isInsertOrReplace = true; String[] sqlParts = new String[2]; sqlParts[0] = sql.substring(0, "INSERT OR REPLACE".length()); sqlParts[1] = sql.substring("INSERT OR REPLACE".length(), sql.length()); sqlParts[0] = sqlParts[0].toUpperCase().replace("INSERT OR REPLACE", "INSERT"); sql = sqlParts[0] + sqlParts[1]; } CCJSqlParser parser = new CCJSqlParser(new StringReader(sql)); try { Statement statement = parser.Statement(); if (isInsertOrReplace && statement instanceof Insert) { statement = new InsertOrReplaceProxy().getInstance(Insert.class, (Insert) statement); } return statement; } catch (Exception ex) { throw new JSQLParserException(ex); } } Statement parse(String sql); }### Answer: @Test public void parse() throws Exception { String sql = "INSERT or replace INTO person (id, name) VALUES (?, ?)"; Insert insert = (Insert) new KbSqlParserManager().parse(sql); Assert.assertEquals("INSERT OR REPLACE INTO person (id, name) VALUES (?, ?)", insert.toString()); }
### Question: ShadowCursor implements Cursor { @Override public String getString(int columnIndex) { Object obj = getObject(columnIndex); return obj == null ? null : obj.toString(); } ShadowCursor(List<String> columns, List<List<Object>> datas); @Override int getCount(); @Override int getPosition(); @Override boolean move(int offset); @Override boolean moveToPosition(int position); @Override boolean moveToFirst(); @Override boolean moveToLast(); @Override boolean moveToNext(); @Override boolean moveToPrevious(); @Override boolean isFirst(); @Override boolean isLast(); @Override boolean isBeforeFirst(); @Override boolean isAfterLast(); @Override int getColumnIndex(String columnName); @Override int getColumnIndexOrThrow(String columnName); @Override String getColumnName(int columnIndex); @Override String[] getColumnNames(); @Override int getColumnCount(); @Override byte[] getBlob(int columnIndex); @Override String getString(int columnIndex); @Override void copyStringToBuffer(int columnIndex, CharArrayBuffer buffer); @Override short getShort(int columnIndex); @Override int getInt(int columnIndex); @Override long getLong(int columnIndex); @Override float getFloat(int columnIndex); @Override double getDouble(int columnIndex); @Override int getType(int columnIndex); @Override boolean isNull(int columnIndex); @Override void deactivate(); @Override boolean requery(); @Override void close(); @Override boolean isClosed(); @Override void registerContentObserver(ContentObserver observer); @Override void unregisterContentObserver(ContentObserver observer); @Override void registerDataSetObserver(DataSetObserver observer); @Override void unregisterDataSetObserver(DataSetObserver observer); @Override void setNotificationUri(ContentResolver cr, Uri uri); @Override Uri getNotificationUri(); @Override boolean getWantsAllOnMoveCalls(); @Override void setExtras(Bundle extras); @Override Bundle getExtras(); @Override Bundle respond(Bundle extras); }### Answer: @Test public void getString() throws Exception { List<String> columns = Arrays.asList("first", "second", "third"); List<Object> datas = Arrays.asList("test", null, new Object()); ShadowCursor cursor = new ShadowCursor(columns, Arrays.asList(datas)); cursor.moveToNext(); Assert.assertEquals("test", cursor.getString(0)); Assert.assertEquals(null, cursor.getString(1)); }
### Question: KbSqlParser { public static String bindArgs(String sql, @Nullable Object[] bindArgs) { if (bindArgs == null \|\| bindArgs.length == 0 \|\| sql.startsWith("PRAGMA")) { return sql; } bindArgs = replaceBoolean(bindArgs); try { KbSqlParserManager pm = new KbSqlParserManager(); Statement statement = pm.parse(sql); Set<Expression> expressionSet = findBindArgsExpressions(statement); Iterator<Object> iterator = Arrays.asList(bindArgs).iterator(); bindExpressionArgs(expressionSet, iterator); return statement.toString(); } catch (Exception e) { e.printStackTrace(); } return sql; } static String bindArgs(String sql, @Nullable Object[] bindArgs); static Object[] replaceBoolean(Object[] bindArgs); }### Answer: @Test public void bindSelectArgs() throws Exception { Object[] args = new Object[]{1, 10, 20, "test"}; String sql = "select * from person where id=? and (uid BETWEEN ? and ?) and test LIKE ? order by id"; String boundSql = KbSqlParser.bindArgs(sql, args); System.out.println(boundSql); Assert.assertEquals("SELECT * FROM person WHERE id = 1 AND (uid BETWEEN 10 AND 20) AND test LIKE 'test' ORDER BY id", boundSql); } @Test public void bindInsertArgs() { Object[] args = new Object[]{1, "kk"}; String sql = "INSERT INTO person (id, name) VALUES (?, ?)"; String boundSql = KbSqlParser.bindArgs(sql, args); Assert.assertEquals("INSERT INTO person (id, name) VALUES (1, 'kk')", boundSql); } @Test public void bindDeleteArgs() { Object[] args = new Object[]{1}; String sql = "DELETE FROM person WHERE id = ?"; String boundSql = KbSqlParser.bindArgs(sql, args); Assert.assertEquals("DELETE FROM person WHERE id = 1", boundSql); } @Test public void bindUpdateArgs() { Object[] args = new Object[]{"kk", 1}; String sql = "UPDATE person SET name = ? WHERE id = ?"; String boundSql = KbSqlParser.bindArgs(sql, args); Assert.assertEquals("UPDATE person SET name = 'kk' WHERE id = 1", boundSql); }
### Question: KbSqlParser { protected static int getBindArgsCount(String sql) { Set<Expression> expressionSet = findBindArgsExpressions(sql); int count = 0; for (Expression expression : expressionSet) { count += getBindArgsCount(expression); } return count; } static String bindArgs(String sql, @Nullable Object[] bindArgs); static Object[] replaceBoolean(Object[] bindArgs); }### Answer: @Test public void getBindArgsCount() throws Exception { String sql0 = "select * from person where id=? and (uid BETWEEN ? and ?) and test LIKE ? order by id"; String sql1 = "INSERT INTO person (id, name) VALUES (?, ?)"; String sql2 = "DELETE FROM person WHERE id in (?,?)"; String sql3 = "UPDATE person SET name = ? WHERE id = ?"; Assert.assertEquals(4, KbSqlParser.getBindArgsCount(sql0)); Assert.assertEquals(2, KbSqlParser.getBindArgsCount(sql1)); Assert.assertEquals(2, KbSqlParser.getBindArgsCount(sql2)); Assert.assertEquals(2, KbSqlParser.getBindArgsCount(sql3)); }
### Question: KbSqlParser { protected static Set<Expression> findBindArgsExpressions(String sql) { if (sql == null \|\| sql.startsWith("PRAGMA") \|\| !sql.contains("?")) { return new LinkedHashSet<>(); } KbSqlParserManager pm = new KbSqlParserManager(); try { Statement statement = pm.parse(sql); Set<Expression> expressionSet = findBindArgsExpressions(statement); return expressionSet; } catch (JSQLParserException e) { e.printStackTrace(); } return new LinkedHashSet<>(); } static String bindArgs(String sql, @Nullable Object[] bindArgs); static Object[] replaceBoolean(Object[] bindArgs); }### Answer: @Test public void findJdbcParamExpressions() throws Exception { String sql = "DELETE FROM person WHERE id = ?"; Set<Expression> expressionSet = KbSqlParser.findBindArgsExpressions(sql); System.out.println(); }
### Question: ShadowContext implements Shadow { public static void deleteAllTempDir() { FileUtils.deletePath(DB_PATH); FileUtils.deletePath(DATA_DIR); FileUtils.deletePath(EXT_DIR); } ShadowContext(Resources resources); @NonNull final String getString(@StringRes int resId); Resources getResources(); SharedPreferences getSharedPreferences(String name, int mode); Context getApplicationContext(); AssetManager getAssets(); File getDatabasePath(String name); String[] databaseList(); static String getDbDir(); File getDataDir(); File getFilesDir(); File getFileStreamPath(String name); File getCacheDir(); File getCodeCacheDir(); File getNoBackupFilesDir(); File getExtDir(); File getExternalCacheDir(); @Nullable File getExternalFilesDir(@Nullable String type); String[] fileList(); String getPackageResourcePath(); String getPackageCodePath(); static void deleteAllTempDir(); void putSQLiteDatabase(String name, SQLiteDatabase db); SQLiteDatabase openOrCreateDatabase(String name, int mode, SQLiteDatabase.CursorFactory factory); @TargetApi(Build.VERSION_CODES.JELLY_BEAN) SQLiteDatabase openOrCreateDatabase(String name, int mode, SQLiteDatabase.CursorFactory factory, DatabaseErrorHandler errorHandler); boolean deleteDatabase(String name); Map<String, SQLiteDatabase> getDbMap(); @Override String toString(); @Override void setProxyObject(Object proxyObject); static final String DB_PATH; }### Answer: @Test public void deleteAllTempDir() throws Exception { ShadowContext.deleteAllTempDir(); }
### Question: NoOpWorkflowImpl implements NoOpWorkflow { @Override public void run() { System.out.println("Run called"); run(0); } @Override void run(); }### Answer: @Test public void testRun() { context.checking( new Expectations() { { exactly(3).of(control).createDatabaseName("test"); will(returnValue("bbb")); } }); new NoOpWorkflowClientFactoryImpl().getClient("test").run(); }
### Question: JobWorkflowImpl implements JobWorkflow { @Override public void executeCommand(final RunJobRequest request) { this.request = request; this.workflowId = contextProvider .getDecisionContext() .getWorkflowContext() .getWorkflowExecution() .getWorkflowId(); final String masterRoleName = "dm-master-role-" + workflowId; final String agentProfileName = "dm-profile-" + workflowId; new TryFinally() { @Override protected void doFinally() { Promise<Void> done = Promise.Void(); if (workerId != null) { done = ec2Activities.terminateInstance(workerId, request.getIdentity()); } done = ec2Activities.deleteInstanceProfile(agentProfileName, request.getIdentity(), done); controlActivities.deleteRole(masterRoleName, done); } @Override protected void doTry() { String taskListName = "dm-agent-tl-" + workflowId; Promise<String> masterRoleArn = controlActivities.createAgentControllerRole( masterRoleName, taskListName, request.getIdentity()); Promise<Void> profileCreated = ec2Activities.createAgentInstanceProfile( Promise.asPromise(agentProfileName), masterRoleArn, Promise.asPromise(request.getIdentity())); Promise<String> userData = controlActivities.createAgentUserData(masterRoleArn, Promise.asPromise(taskListName)); Promise<String> workerId = launchInstances(agentProfileName, userData, profileCreated); Promise<Void> set = setWorkerId(workerId); Promise<Void> ready = waitUntilWorkerReady(workerId, set); Promise<String> actionId = controlActivities.notifyActionStarted( "AgentActivities.runJob", "Start running command on instance", ready); Promise<JobResult> result = agentActivities.runJob( request.getJob(), new ActivitySchedulingOptions() .withTaskList(taskListName) .withStartToCloseTimeoutSeconds( request.getWorkerOptions().getJobTimeoutSeconds()), actionId); reportResult(actionId, result); } }; } @Override void executeCommand(final RunJobRequest request); }### Answer: @Test public void testRun() { final Identity identity = Identity.of("a", "b", "c"); WorkerOptions workerOptions = new WorkerOptions(); RunJobRequest request = new RunJobRequest(); request.setWorkerOptions(workerOptions); final Job job = new CommandLineJob(); request.setIdentity(identity); request.setJob(job); final CreateInstanceOptions options = new CreateInstanceOptions(); options.setWorkerOptions(workerOptions); options.setInstanceProfileName("dm-profile-test"); options.setUserData("test-data"); final JobResult result = new JobResult(); result.setStandardOutput("something"); result.setElapsedMillis(1000); context.checking( new Expectations() { { one(controlActivities) .createAgentControllerRole("dm-master-role-test", "dm-agent-tl-test", identity); will(returnValue("aws:test:arn")); one(ec2Activities) .createAgentInstanceProfile("dm-profile-test", "aws:test:arn", identity); one(controlActivities).createAgentUserData("aws:test:arn", "dm-agent-tl-test"); will(returnValue("test-data")); one(ec2Activities).launchInstance(options, identity); will(returnValue("dmw-test")); one(ec2Activities).describeInstance("dmw-test", identity); will(returnValue(new WorkerInstance().withInstanceStatus("running"))); one(controlActivities) .notifyActionStarted("AgentActivities.runJob", "Start running command on instance"); will(returnValue("action-id")); one(agentActivities).runJob(job); will(returnValue(result)); one(controlActivities) .notifyActionCompleted( with(equal("action-id")), with(aNonNull(String.class)), with(equal(1000L))); one(ec2Activities).terminateInstance("dmw-test", identity); one(ec2Activities).deleteInstanceProfile("dm-profile-test", identity); one(controlActivities).deleteRole("dm-master-role-test"); } }); new JobWorkflowClientFactoryImpl().getClient("test").executeCommand(request); }
### Question: UriBuilderImpl extends UriBuilder { @Override public UriBuilder replaceQueryParam(String name, Object... values) { checkSsp(); if (queryParams == null) { queryParams = UriComponent.decodeQuery(query.toString(), false); query.setLength(0); } name = encode(name, UriComponent.Type.QUERY_PARAM); queryParams.remove(name); if (values == null) { return this; } for (Object value : values) { if (value == null) { throw new IllegalArgumentException("One or more of query value parameters are null"); } queryParams.add(name, encode(value.toString(), UriComponent.Type.QUERY_PARAM)); } return this; } UriBuilderImpl(); private UriBuilderImpl(UriBuilderImpl that); @Override UriBuilder clone(); @Override UriBuilder uri(URI uri); @Override UriBuilder scheme(String scheme); @Override UriBuilder schemeSpecificPart(String ssp); @Override UriBuilder userInfo(String ui); @Override UriBuilder host(String host); @Override UriBuilder port(int port); @Override UriBuilder replacePath(String path); @Override UriBuilder path(String path); @Override UriBuilder path(Class resource); @Override UriBuilder path(Class resource, String methodName); @Override UriBuilder path(Method method); @Override UriBuilder segment(String... segments); @Override UriBuilder replaceMatrix(String matrix); @Override UriBuilder matrixParam(String name, Object... values); @Override UriBuilder replaceMatrixParam(String name, Object... values); @Override UriBuilder replaceQuery(String query); @Override UriBuilder queryParam(String name, Object... values); @Override UriBuilder replaceQueryParam(String name, Object... values); @Override UriBuilder fragment(String fragment); @Override URI buildFromMap(Map<String, ? extends Object> values); @Override URI buildFromEncodedMap(Map<String, ? extends Object> values); @Override URI build(Object... values); @Override URI buildFromEncoded(Object... values); }### Answer: @Test public void testReplaceQueryParam() { URI uri = new UriBuilderImpl().path("http: assertEquals("http: }
### Question: DemoAO { public void hello(String name) throws FileNotFoundException { System.out.println(demoService.sayHello(name)); } void hello(String name); }### Answer: @Test public void testHello() throws FileNotFoundException { demoAO.hello("抠逼阵儿"); }
### Question: StackTraceHelper { public static StackFrame[] convertJsStackTrace(@Nullable ReadableArray stack) { int size = stack != null ? stack.size() : 0; StackFrame[] result = new StackFrame[size]; for (int i = 0; i < size; i++) { ReadableMap frame = stack.getMap(i); String methodName = frame.getString("methodName"); String fileName = frame.getString("file"); int lineNumber = -1; if (frame.hasKey(LINE_NUMBER_KEY) && !frame.isNull(LINE_NUMBER_KEY)) { lineNumber = frame.getInt(LINE_NUMBER_KEY); } int columnNumber = -1; if (frame.hasKey(COLUMN_KEY) && !frame.isNull(COLUMN_KEY)) { columnNumber = frame.getInt(COLUMN_KEY); } result[i] = new StackFrameImpl(fileName, methodName, lineNumber, columnNumber); } return result; } static StackFrame[] convertJsStackTrace(@Nullable ReadableArray stack); static StackFrame[] convertJsStackTrace(JSONArray stack); static StackFrame[] convertJsStackTrace(String stack); static StackFrame[] convertJavaStackTrace(Throwable exception); static String formatFrameSource(StackFrame frame); static String formatStackTrace(String title, StackFrame[] stack); static final java.lang.String COLUMN_KEY; static final java.lang.String LINE_NUMBER_KEY; }### Answer: @Test public void testParseStackFrameWithMethod() { final StackFrame frame = StackTraceHelper.convertJsStackTrace( "[email protected]:1:2000")[0]; assertThat(frame.getMethod()).isEqualTo("render"); assertThat(frame.getFileName()).isEqualTo("Test.bundle"); assertThat(frame.getLine()).isEqualTo(1); assertThat(frame.getColumn()).isEqualTo(2000); } @Test public void testParseStackFrameWithoutMethod() { final StackFrame frame = StackTraceHelper.convertJsStackTrace( "Test.bundle:1:2000")[0]; assertThat(frame.getMethod()).isEqualTo("(unknown)"); assertThat(frame.getFileName()).isEqualTo("Test.bundle"); assertThat(frame.getLine()).isEqualTo(1); assertThat(frame.getColumn()).isEqualTo(2000); } @Test public void testParseStackFrameWithInvalidFrame() { try { StackTraceHelper.convertJsStackTrace("Test.bundle:ten:twenty"); failBecauseExceptionWasNotThrown(IllegalArgumentException.class); } catch (Exception e) { assertThat(e).isInstanceOf(IllegalArgumentException.class); } }
### Question: ClipboardModule extends ContextBaseJavaModule { @SuppressLint("DeprecatedMethod") @ReactMethod public void setString(String text) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) { ClipData clipdata = ClipData.newPlainText(null, text); ClipboardManager clipboard = getClipboardService(); clipboard.setPrimaryClip(clipdata); } else { ClipboardManager clipboard = getClipboardService(); clipboard.setText(text); } } ClipboardModule(Context context); @Override String getName(); @ReactMethod void getString(Promise promise); @SuppressLint("DeprecatedMethod") @ReactMethod void setString(String text); }### Answer: @Test public void testSetString() { mClipboardModule.setString(TEST_CONTENT); assertTrue(mClipboardManager.getText().equals(TEST_CONTENT)); mClipboardModule.setString(null); assertFalse(mClipboardManager.hasText()); mClipboardModule.setString(""); assertFalse(mClipboardManager.hasText()); mClipboardModule.setString(" "); assertTrue(mClipboardManager.hasText()); }
### Question: UIManagerModule extends ReactContextBaseJavaModule implements OnBatchCompleteListener, LifecycleEventListener, PerformanceCounter { @ReactMethod public void replaceExistingNonRootView(int oldTag, int newTag) { mUIImplementation.replaceExistingNonRootView(oldTag, newTag); } UIManagerModule( ReactApplicationContext reactContext, List<ViewManager> viewManagerList, UIImplementationProvider uiImplementationProvider, boolean lazyViewManagersEnabled); UIImplementation getUIImplementation(); @Override String getName(); @Override Map<String, Object> getConstants(); @Override void initialize(); @Override void onHostResume(); @Override void onHostPause(); @Override void onHostDestroy(); @Override void onCatalystInstanceDestroy(); Map<String,Double> getPerformanceCounters(); int addMeasuredRootView(final SizeMonitoringFrameLayout rootView); @ReactMethod void removeRootView(int rootViewTag); void updateNodeSize(int nodeViewTag, int newWidth, int newHeight); @ReactMethod void createView(int tag, String className, int rootViewTag, ReadableMap props); @ReactMethod void updateView(int tag, String className, ReadableMap props); @ReactMethod void manageChildren( int viewTag, @Nullable ReadableArray moveFrom, @Nullable ReadableArray moveTo, @Nullable ReadableArray addChildTags, @Nullable ReadableArray addAtIndices, @Nullable ReadableArray removeFrom); @ReactMethod void setChildren( int viewTag, ReadableArray childrenTags); @ReactMethod void replaceExistingNonRootView(int oldTag, int newTag); @ReactMethod void removeSubviewsFromContainerWithID(int containerTag); @ReactMethod void measure(int reactTag, Callback callback); @ReactMethod void measureInWindow(int reactTag, Callback callback); @ReactMethod void measureLayout( int tag, int ancestorTag, Callback errorCallback, Callback successCallback); @ReactMethod void measureLayoutRelativeToParent( int tag, Callback errorCallback, Callback successCallback); @ReactMethod void findSubviewIn( final int reactTag, final ReadableArray point, final Callback callback); void registerAnimation(Animation animation); void addAnimation(int reactTag, int animationID, Callback onSuccess); void removeAnimation(int reactTag, int animationID); @ReactMethod void setJSResponder(int reactTag, boolean blockNativeResponder); @ReactMethod void clearJSResponder(); @ReactMethod void dispatchViewManagerCommand(int reactTag, int commandId, ReadableArray commandArgs); @ReactMethod void showPopupMenu(int reactTag, ReadableArray items, Callback error, Callback success); @ReactMethod void setLayoutAnimationEnabledExperimental(boolean enabled); @ReactMethod void configureNextLayoutAnimation( ReadableMap config, Callback success, Callback error); @Override void onBatchComplete(); void setViewHierarchyUpdateDebugListener( @Nullable NotThreadSafeViewHierarchyUpdateDebugListener listener); EventDispatcher getEventDispatcher(); @ReactMethod void sendAccessibilityEvent(int tag, int eventType); void addUIBlock(UIBlock block); int resolveRootTagFromReactTag(int reactTag); }### Answer: @Test public void testReplaceExistingNonRootView() { UIManagerModule uiManager = getUIManagerModule(); TestMoveDeleteHierarchy hierarchy = createMoveDeleteHierarchy(uiManager); int newViewTag = 1234; uiManager.createView( newViewTag, ReactViewManager.REACT_CLASS, hierarchy.rootView, JavaOnlyMap.of("backgroundColor", Color.RED)); uiManager.replaceExistingNonRootView(hierarchy.view2, newViewTag); uiManager.onBatchComplete(); executePendingFrameCallbacks(); assertThat(hierarchy.nativeRootView.getChildCount()).isEqualTo(4); assertThat(hierarchy.nativeRootView.getChildAt(2)).isInstanceOf(ReactViewGroup.class); ReactViewGroup view = (ReactViewGroup) hierarchy.nativeRootView.getChildAt(2); assertThat(view.getBackgroundColor()).isEqualTo(Color.RED); }
### Question: CompositeReactPackage extends ReactInstancePackage { @Override public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) { final Map<String, NativeModule> moduleMap = new HashMap<>(); for (ReactPackage reactPackage: mChildReactPackages) { for (NativeModule nativeModule: reactPackage.createNativeModules(reactContext)) { moduleMap.put(nativeModule.getName(), nativeModule); } } return new ArrayList(moduleMap.values()); } CompositeReactPackage(ReactPackage arg1, ReactPackage arg2, ReactPackage... args); @Override List<NativeModule> createNativeModules(ReactApplicationContext reactContext); @Override List<NativeModule> createNativeModules( ReactApplicationContext reactContext, ReactInstanceManager reactInstanceManager); @Override List<Class<? extends JavaScriptModule>> createJSModules(); @Override List<ViewManager> createViewManagers(ReactApplicationContext reactContext); }### Answer: @Test public void testThatCreateNativeModulesIsCalledOnAllPackages() { CompositeReactPackage composite = new CompositeReactPackage(packageNo1, packageNo2, packageNo3); composite.createNativeModules(reactContext); verify(packageNo1).createNativeModules(reactContext); verify(packageNo2).createNativeModules(reactContext); verify(packageNo3).createNativeModules(reactContext); } @Test public void testThatCompositeReturnsASumOfNativeModules() { CompositeReactPackage composite = new CompositeReactPackage(packageNo1, packageNo2); NativeModule moduleNo1 = mock(NativeModule.class); when(moduleNo1.getName()).thenReturn("ModuleNo1"); final String sameModuleName = "SameModuleName"; NativeModule moduleNo2 = mock(NativeModule.class); when(moduleNo2.getName()).thenReturn(sameModuleName); NativeModule moduleNo3 = mock(NativeModule.class); when(moduleNo3.getName()).thenReturn(sameModuleName); NativeModule moduleNo4 = mock(NativeModule.class); when(moduleNo4.getName()).thenReturn("ModuleNo4"); when(packageNo1.createNativeModules(reactContext)).thenReturn( Arrays.asList(new NativeModule[]{moduleNo1, moduleNo2})); when(packageNo2.createNativeModules(reactContext)).thenReturn( Arrays.asList(new NativeModule[]{moduleNo3, moduleNo4})); List<NativeModule> compositeModules = composite.createNativeModules(reactContext); Set<NativeModule> expected = new HashSet<>( Arrays.asList(new NativeModule[]{moduleNo1, moduleNo3, moduleNo4})); Set<NativeModule> actual = new HashSet<>(compositeModules); assertEquals(expected, actual); }
### Question: CompositeReactPackage extends ReactInstancePackage { @Override public List<Class<? extends JavaScriptModule>> createJSModules() { final Set<Class<? extends JavaScriptModule>> moduleSet = new HashSet<>(); for (ReactPackage reactPackage: mChildReactPackages) { for (Class<? extends JavaScriptModule> jsModule: reactPackage.createJSModules()) { moduleSet.add(jsModule); } } return new ArrayList(moduleSet); } CompositeReactPackage(ReactPackage arg1, ReactPackage arg2, ReactPackage... args); @Override List<NativeModule> createNativeModules(ReactApplicationContext reactContext); @Override List<NativeModule> createNativeModules( ReactApplicationContext reactContext, ReactInstanceManager reactInstanceManager); @Override List<Class<? extends JavaScriptModule>> createJSModules(); @Override List<ViewManager> createViewManagers(ReactApplicationContext reactContext); }### Answer: @Test public void testThatCreateJSModulesIsCalledOnAllPackages() { CompositeReactPackage composite = new CompositeReactPackage(packageNo1, packageNo2, packageNo3); composite.createJSModules(); verify(packageNo1).createJSModules(); verify(packageNo2).createJSModules(); verify(packageNo3).createJSModules(); } @Test public void testThatCompositeReturnsASumOfJSModules() { CompositeReactPackage composite = new CompositeReactPackage(packageNo1, packageNo2); Class<? extends JavaScriptModule> moduleNo1 = mock(JavaScriptModuleNo1.class).getClass(); Class<? extends JavaScriptModule> moduleNo2 = mock(JavaScriptModuleNo2.class).getClass(); Class<? extends JavaScriptModule> moduleNo3 = mock(JavaScriptModuleNo3.class).getClass(); List<Class<? extends JavaScriptModule>> l1 = new ArrayList<>(); l1.add(moduleNo1); when(packageNo1.createJSModules()).thenReturn(l1); List<Class<? extends JavaScriptModule>> l2 = new ArrayList<>(); l2.add(moduleNo2); l2.add(moduleNo3); when(packageNo2.createJSModules()).thenReturn(l2); List<Class<? extends JavaScriptModule>> compositeModules = composite.createJSModules(); List<Class<? extends JavaScriptModule>> l3 = new ArrayList<>(); l3.add(moduleNo1); l3.add(moduleNo2); l3.add(moduleNo3); Set<Class<? extends JavaScriptModule>> expected = new HashSet<>(l3); Set<Class<? extends JavaScriptModule>> actual = new HashSet<>(compositeModules); assertEquals(expected, actual); }
### Question: CompositeReactPackage extends ReactInstancePackage { @Override public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) { final Map<String, ViewManager> viewManagerMap = new HashMap<>(); for (ReactPackage reactPackage: mChildReactPackages) { for (ViewManager viewManager: reactPackage.createViewManagers(reactContext)) { viewManagerMap.put(viewManager.getName(), viewManager); } } return new ArrayList(viewManagerMap.values()); } CompositeReactPackage(ReactPackage arg1, ReactPackage arg2, ReactPackage... args); @Override List<NativeModule> createNativeModules(ReactApplicationContext reactContext); @Override List<NativeModule> createNativeModules( ReactApplicationContext reactContext, ReactInstanceManager reactInstanceManager); @Override List<Class<? extends JavaScriptModule>> createJSModules(); @Override List<ViewManager> createViewManagers(ReactApplicationContext reactContext); }### Answer: @Test public void testThatCreateViewManagersIsCalledOnAllPackages() { CompositeReactPackage composite = new CompositeReactPackage(packageNo1, packageNo2, packageNo3); composite.createViewManagers(reactContext); verify(packageNo1).createViewManagers(reactContext); verify(packageNo2).createViewManagers(reactContext); verify(packageNo3).createViewManagers(reactContext); } @Test public void testThatCompositeReturnsASumOfViewManagers() { CompositeReactPackage composite = new CompositeReactPackage(packageNo1, packageNo2); ViewManager managerNo1 = mock(ViewManager.class); when(managerNo1.getName()).thenReturn("ManagerNo1"); final String sameModuleName = "SameModuleName"; ViewManager managerNo2 = mock(ViewManager.class); when(managerNo2.getName()).thenReturn(sameModuleName); ViewManager managerNo3 = mock(ViewManager.class); when(managerNo3.getName()).thenReturn(sameModuleName); ViewManager managerNo4 = mock(ViewManager.class); when(managerNo4.getName()).thenReturn("ManagerNo4"); when(packageNo1.createViewManagers(reactContext)).thenReturn( Arrays.asList(new ViewManager[]{managerNo1, managerNo2})); when(packageNo2.createViewManagers(reactContext)).thenReturn( Arrays.asList(new ViewManager[]{managerNo3, managerNo4})); List<ViewManager> compositeModules = composite.createViewManagers(reactContext); Set<ViewManager> expected = new HashSet<>( Arrays.asList(new ViewManager[]{managerNo1, managerNo3, managerNo4}) ); Set<ViewManager> actual = new HashSet<>(compositeModules); assertEquals(expected, actual); }
### Question: PdfParser { static List<String> extractTextLinesFromPdf(InputStream pdfStream) { PdfReader pdfReader = null; try { pdfReader = new PdfReader(pdfStream); List<String> textLines = new ArrayList<>(); for (int page = 1; page <= pdfReader.getNumberOfPages(); page++) { String textFromPage = PdfTextExtractor.getTextFromPage(pdfReader, page); String[] linesFromPage = textFromPage.split("\n"); for (String lineFromPage : linesFromPage) { lineFromPage = lineFromPage.trim(); int previousLength; do { previousLength = lineFromPage.length(); lineFromPage = lineFromPage.replaceAll(" ", " "); } while (previousLength != lineFromPage.length()); if (isTextLinePdfParsingJunk(lineFromPage)) continue; textLines.add(lineFromPage); } } return textLines; } catch (IOException e) { throw new UncheckedIOException(e); } finally { if (pdfReader != null) pdfReader.close(); } } static Codebook parseCodebookPdf(SupportedCodebook codebookSource); static final String FIELD_NAME_LABEL; static final String FIELD_NAME_DESCRIPTION; static final String FIELD_NAME_SHORT_NAME; static final String FIELD_NAME_LONG_NAME; static final String FIELD_NAME_TYPE; }### Answer: @Test public void extractTextLinesFromPdf_ffsClaims() throws IOException { try (InputStream codebookPdfStream = SupportedCodebook.FFS_CLAIMS.getCodebookPdfInputStream();) { List<String> codebookTextLines = PdfParser.extractTextLinesFromPdf(codebookPdfStream); Assert.assertNotNull(codebookTextLines); Assert.assertTrue(codebookTextLines.size() > 100); } }
### Question: PdfParser { static List<List<String>> findVariableSections(List<String> codebookTextLines) { int firstVariableLine = findFirstVariableLine(codebookTextLines); int lastVariableLine = findLastVariableLine(codebookTextLines); List<List<String>> variableSectionLineGroups = new ArrayList<>(); List<String> sectionBuilder = new ArrayList<>(); for (int lineIndex = firstVariableLine; lineIndex <= lastVariableLine; lineIndex++) { String line = codebookTextLines.get(lineIndex); if (!isDocumentMetadata(line)) sectionBuilder.add(line); if (containsVariableLabelField(line)) { if (sectionBuilder.size() == 2) { } else { List<String> completedSection = sectionBuilder.subList(0, sectionBuilder.size() - 2); variableSectionLineGroups.add(new ArrayList<>(completedSection)); completedSection.clear(); } } } if (!sectionBuilder.isEmpty()) variableSectionLineGroups.add(new ArrayList<>(sectionBuilder)); return variableSectionLineGroups; } static Codebook parseCodebookPdf(SupportedCodebook codebookSource); static final String FIELD_NAME_LABEL; static final String FIELD_NAME_DESCRIPTION; static final String FIELD_NAME_SHORT_NAME; static final String FIELD_NAME_LONG_NAME; static final String FIELD_NAME_TYPE; }### Answer: @Test public void findVariableSections() throws IOException { for (SupportedCodebook supportedCodebook : SupportedCodebook.values()) { try (InputStream codebookPdfStream = supportedCodebook.getCodebookPdfInputStream();) { LOGGER.info("Looking for sections in codebook: {}", supportedCodebook.name()); List<String> codebookTextLines = PdfParser.extractTextLinesFromPdf(codebookPdfStream); List<List<String>> variableSections = PdfParser.findVariableSections(codebookTextLines); for (List<String> variableSection : variableSections) { Assert.assertNotNull(variableSection); Assert.assertTrue(variableSection.size() >= 10); } Predicate<? super String> searchFieldFilter = l -> l.startsWith("SHORT_NAME:"); List<String> searchFieldLines = codebookTextLines.stream().filter(searchFieldFilter) .collect(Collectors.toList()); Assert.assertEquals("Not all instances of that field are unique.", searchFieldLines.size(), new HashSet<>(searchFieldLines).size()); for (String searchFieldLine : searchFieldLines) { boolean foundSection = false; for (List<String> variableSection : variableSections) { for (String line : variableSection) if (searchFieldLine.equals(line)) foundSection = true; } Assert.assertTrue(String.format("Can't find search field line: '%s'", searchFieldLine), foundSection); } } } }
### Question: PdfParser { static String parseLabel(List<String> variableSection) { List<String> fieldText = extractFieldContent(variableSection, FIELD_NAME_LABEL, FIELD_NAME_LABEL_ALT1); List<String> fieldParagraphs = extractParagraphs(fieldText); if (fieldParagraphs.size() != 1) throw new IllegalStateException( String.format("Invalid '%s' field in variable section: %s", FIELD_NAME_LABEL, variableSection)); return fieldParagraphs.get(0); } static Codebook parseCodebookPdf(SupportedCodebook codebookSource); static final String FIELD_NAME_LABEL; static final String FIELD_NAME_DESCRIPTION; static final String FIELD_NAME_SHORT_NAME; static final String FIELD_NAME_LONG_NAME; static final String FIELD_NAME_TYPE; }### Answer: @Test public void parseLabel_multiline() { String[] variableSection = new String[] { "CLM_NEXT_GNRTN_ACO_IND_CD1", "LABEL: Claim Next Generation (NG) Accountable Care Organization (ACO) Indicator Code –", "Population-Based Payment (PBP)", "DESCRIPTION: The field identifies the claims that qualify for specific claims processing edits" + " related to", }; String parsedLabel = PdfParser.parseLabel(Arrays.asList(variableSection)); Assert.assertEquals( "Claim Next Generation (NG) Accountable Care Organization (ACO) Indicator Code – Population-Based" + " Payment (PBP)", parsedLabel); }
### Question: DatabaseSchemaManager { public static void createOrUpdateSchema(DataSource dataSource) { LOGGER.info("Schema create/upgrade: running..."); Flyway flyway = new Flyway(); flyway.setCleanDisabled(true); flyway.setDataSource(dataSource); flyway.setPlaceholders(createScriptPlaceholdersMap(dataSource)); flyway.migrate(); LOGGER.info("Schema create/upgrade: complete."); } static void createOrUpdateSchema(DataSource dataSource); static void dropIndexes(DataSource dataSource); }### Answer: @Test public void createOrUpdateSchemaOnHsql() { JDBCDataSource hsqlDataSource = new JDBCDataSource(); hsqlDataSource.setUrl("jdbc:hsqldb:mem:test"); DatabaseSchemaManager.createOrUpdateSchema(hsqlDataSource); }
### Question: CommandContext { public boolean hasFlag(char ch) { return booleanFlags.contains(ch) \|\| valueFlags.containsKey(ch); } CommandContext(String args); CommandContext(String[] args); CommandContext(String args, Set<Character> valueFlags); CommandContext(String args, Set<Character> valueFlags, boolean allowHangingFlag); CommandContext(String[] args, Set<Character> valueFlags); CommandContext(String[] args, Set<Character> valueFlags, boolean allowHangingFlag, CommandLocals locals); CommandContext(String[] args, Set<Character> valueFlags, boolean allowHangingFlag, CommandLocals locals, boolean parseFlags); static String[] split(String args); SuggestionContext getSuggestionContext(); String getCommand(); boolean matches(String command); String getString(int index); String getString(int index, String def); String getJoinedStrings(int initialIndex); String getRemainingString(int start); String getString(int start, int end); int getInteger(int index); int getInteger(int index, int def); double getDouble(int index); double getDouble(int index, double def); String[] getSlice(int index); String[] getPaddedSlice(int index, int padding); String[] getParsedSlice(int index); String[] getParsedPaddedSlice(int index, int padding); boolean hasFlag(char ch); Set<Character> getFlags(); Map<Character, String> getValueFlags(); String getFlag(char ch); String getFlag(char ch, String def); int getFlagInteger(char ch); int getFlagInteger(char ch, int def); double getFlagDouble(char ch); double getFlagDouble(char ch, double def); int argsLength(); CommandLocals getLocals(); }### Answer: @Test public void testFlagsAnywhere() { try { CommandContext context = new CommandContext("r hello -f"); assertTrue(context.hasFlag('f')); CommandContext context2 = new CommandContext("r hello -f world"); assertTrue(context2.hasFlag('f')); } catch (CommandException e) { log.warn("Error", e); fail("Error creating CommandContext"); } }
### Question: Location { public Location setY(double y) { return new Location(extent, position.withY(y), yaw, pitch); } Location(Extent extent); Location(Extent extent, double x, double y, double z); Location(Extent extent, Vector3 position); Location(Extent extent, double x, double y, double z, Vector3 direction); Location(Extent extent, double x, double y, double z, float yaw, float pitch); Location(Extent extent, Vector3 position, Vector3 direction); Location(Extent extent, Vector3 position, float yaw, float pitch); Extent getExtent(); Location setExtent(Extent extent); float getYaw(); Location setYaw(float yaw); float getPitch(); Location setPitch(float pitch); Location setDirection(float yaw, float pitch); Vector3 getDirection(); Direction getDirectionEnum(); Location setDirection(Vector3 direction); Vector3 toVector(); double getX(); int getBlockX(); Location setX(double x); double getY(); int getBlockY(); Location setY(double y); double getZ(); int getBlockZ(); Location setZ(double z); Location setPosition(Vector3 position); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testSetY() throws Exception { World world = mock(World.class); Location location1 = new Location(world, Vector3.ZERO); Location location2 = location1.setY(TEST_VALUE); assertEquals(0, location1.getY(), EPSILON); assertEquals(0, location2.getX(), EPSILON); assertEquals(TEST_VALUE, location2.getY(), EPSILON); assertEquals(0, location2.getZ(), EPSILON); }
### Question: Location { public double getZ() { return position.getZ(); } Location(Extent extent); Location(Extent extent, double x, double y, double z); Location(Extent extent, Vector3 position); Location(Extent extent, double x, double y, double z, Vector3 direction); Location(Extent extent, double x, double y, double z, float yaw, float pitch); Location(Extent extent, Vector3 position, Vector3 direction); Location(Extent extent, Vector3 position, float yaw, float pitch); Extent getExtent(); Location setExtent(Extent extent); float getYaw(); Location setYaw(float yaw); float getPitch(); Location setPitch(float pitch); Location setDirection(float yaw, float pitch); Vector3 getDirection(); Direction getDirectionEnum(); Location setDirection(Vector3 direction); Vector3 toVector(); double getX(); int getBlockX(); Location setX(double x); double getY(); int getBlockY(); Location setY(double y); double getZ(); int getBlockZ(); Location setZ(double z); Location setPosition(Vector3 position); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testGetZ() throws Exception { World world = mock(World.class); Location location = new Location(world, Vector3.at(0, 0, TEST_VALUE)); assertEquals(TEST_VALUE, location.getZ(), EPSILON); }
### Question: Location { public int getBlockZ() { return (int) Math.floor(position.getZ()); } Location(Extent extent); Location(Extent extent, double x, double y, double z); Location(Extent extent, Vector3 position); Location(Extent extent, double x, double y, double z, Vector3 direction); Location(Extent extent, double x, double y, double z, float yaw, float pitch); Location(Extent extent, Vector3 position, Vector3 direction); Location(Extent extent, Vector3 position, float yaw, float pitch); Extent getExtent(); Location setExtent(Extent extent); float getYaw(); Location setYaw(float yaw); float getPitch(); Location setPitch(float pitch); Location setDirection(float yaw, float pitch); Vector3 getDirection(); Direction getDirectionEnum(); Location setDirection(Vector3 direction); Vector3 toVector(); double getX(); int getBlockX(); Location setX(double x); double getY(); int getBlockY(); Location setY(double y); double getZ(); int getBlockZ(); Location setZ(double z); Location setPosition(Vector3 position); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testGetBlockZ() throws Exception { World world = mock(World.class); Location location = new Location(world, Vector3.at(0, 0, TEST_VALUE)); assertEquals(TEST_VALUE, location.getBlockZ()); }
### Question: Location { public Location setZ(double z) { return new Location(extent, position.withZ(z), yaw, pitch); } Location(Extent extent); Location(Extent extent, double x, double y, double z); Location(Extent extent, Vector3 position); Location(Extent extent, double x, double y, double z, Vector3 direction); Location(Extent extent, double x, double y, double z, float yaw, float pitch); Location(Extent extent, Vector3 position, Vector3 direction); Location(Extent extent, Vector3 position, float yaw, float pitch); Extent getExtent(); Location setExtent(Extent extent); float getYaw(); Location setYaw(float yaw); float getPitch(); Location setPitch(float pitch); Location setDirection(float yaw, float pitch); Vector3 getDirection(); Direction getDirectionEnum(); Location setDirection(Vector3 direction); Vector3 toVector(); double getX(); int getBlockX(); Location setX(double x); double getY(); int getBlockY(); Location setY(double y); double getZ(); int getBlockZ(); Location setZ(double z); Location setPosition(Vector3 position); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testSetZ() throws Exception { World world = mock(World.class); Location location1 = new Location(world, Vector3.ZERO); Location location2 = location1.setZ(TEST_VALUE); assertEquals(0, location1.getZ(), EPSILON); assertEquals(0, location2.getX(), EPSILON); assertEquals(0, location2.getY(), EPSILON); assertEquals(TEST_VALUE, location2.getZ(), EPSILON); }
### Question: MorePaths { public static Stream<Path> iterPaths(Path path) { Deque<Path> parents = new ArrayDeque<>(path.getNameCount()); Path next = path; while (next != null) { parents.addFirst(next); next = next.getParent(); } return ImmutableList.copyOf(parents).stream(); } private MorePaths(); static Comparator<Path> oldestFirst(); static Comparator<Path> newestFirst(); static Stream<Path> iterPaths(Path path); static Spliterator<Path> optimizedSpliterator(Path path); }### Answer: @Test void testRelative() { assertEquals( paths("a", "a/b", "a/b/c"), MorePaths.iterPaths(Paths.get("a/b/c")).collect(toList()) ); } @Test void testAbsolute() { assertEquals( paths("/", "/a", "/a/b", "/a/b/c"), MorePaths.iterPaths(Paths.get("/a/b/c")).collect(toList()) ); } @Test void testEmpty() { assertEquals( paths(""), MorePaths.iterPaths(Paths.get("")).collect(toList()) ); } @Test void testJustFile() { assertEquals( paths("a"), MorePaths.iterPaths(Paths.get("a")).collect(toList()) ); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.