method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
MemoryReactiveStore implements ReactiveStore<Key, Value> { public void storeSingular(@NonNull final Value model) { final Key key = extractKeyFromModel.call(model); cache.putSingular(model); getOrCreateSubjectForKey(key).onNext(ofObj(model)); final Option<List<Value>> allValues = cache.getAll().map(Option::ofObj).blockingGet(none()); allSubject.onNext(allValues); } MemoryReactiveStore(@NonNull final Func1<Value, Key> extractKeyFromModel,
@NonNull final Store.MemoryStore<Key, Value> cache); void storeSingular(@NonNull final Value model); void storeAll(@NonNull final List<Value> modelList); void replaceAll(@NonNull final List<Value> modelList); @NonNull Observable<Option<Value>> getSingular(@NonNull final Key key); @NonNull Observable<Option<List<Value>>> getAll(); }### Answer:
@Test public void objectIsStoredInCache() { TestObject model = new TestObject("ID1"); new ArrangeBuilder().withCachedObjectList(Collections.singletonList(model)); reactiveStore.storeSingular(model); Mockito.verify(cache).putSingular(model); } |
### Question:
MemoryReactiveStore implements ReactiveStore<Key, Value> { public void storeAll(@NonNull final List<Value> modelList) { cache.putAll(modelList); allSubject.onNext(ofObj(modelList)); publishInEachKey(); } MemoryReactiveStore(@NonNull final Func1<Value, Key> extractKeyFromModel,
@NonNull final Store.MemoryStore<Key, Value> cache); void storeSingular(@NonNull final Value model); void storeAll(@NonNull final List<Value> modelList); void replaceAll(@NonNull final List<Value> modelList); @NonNull Observable<Option<Value>> getSingular(@NonNull final Key key); @NonNull Observable<Option<List<Value>>> getAll(); }### Answer:
@Test public void objectListIsStoredInCache() { List<TestObject> list = createTestObjectList(); reactiveStore.storeAll(list); Mockito.verify(cache).putAll(list); } |
### Question:
MemoryReactiveStore implements ReactiveStore<Key, Value> { public void replaceAll(@NonNull final List<Value> modelList) { cache.clear(); storeAll(modelList); } MemoryReactiveStore(@NonNull final Func1<Value, Key> extractKeyFromModel,
@NonNull final Store.MemoryStore<Key, Value> cache); void storeSingular(@NonNull final Value model); void storeAll(@NonNull final List<Value> modelList); void replaceAll(@NonNull final List<Value> modelList); @NonNull Observable<Option<Value>> getSingular(@NonNull final Key key); @NonNull Observable<Option<List<Value>>> getAll(); }### Answer:
@Test public void cacheIsClearedInReplaceAll() { List<TestObject> list = createTestObjectList(); reactiveStore.replaceAll(list); Mockito.verify(cache).clear(); } |
### Question:
Cache implements MemoryStore<Key, Value> { @Override @NonNull public Maybe<Value> getSingular(@NonNull final Key key) { return Maybe.fromCallable(() -> cache.containsKey(key)) .filter(isPresent -> isPresent) .map(__ -> cache.get(key)) .filter(this::notExpired) .map(CacheEntry::cachedObject) .subscribeOn(Schedulers.computation()); } Cache(@NonNull final Function<Value, Key> extractKeyFromModel,
@NonNull final TimestampProvider timestampProvider); Cache(@NonNull final Function<Value, Key> extractKeyFromModel,
@NonNull final TimestampProvider timestampProvider,
final long timeoutMs); private Cache(@NonNull final Function<Value, Key> extractKeyFromModel,
@NonNull final TimestampProvider timestampProvider,
@NonNull final Option<Long> timeoutMs); @Override void putSingular(@NonNull Value value); @Override void putAll(@NonNull List<Value> values); @Override @NonNull Maybe<Value> getSingular(@NonNull final Key key); @Override @NonNull Maybe<List<Value>> getAll(); @Override void clear(); }### Answer:
@Test public void getSingularCompletesWithNoEmissionsWhenCacheIsEmpty() { cache.getSingular("KEY").test().assertNoValues(); } |
### Question:
Cache implements MemoryStore<Key, Value> { @Override @NonNull public Maybe<List<Value>> getAll() { return Observable.fromIterable(cache.values()) .filter(this::notExpired) .map(CacheEntry::cachedObject) .toList() .filter(ListUtils::isNotEmpty) .subscribeOn(Schedulers.computation()); } Cache(@NonNull final Function<Value, Key> extractKeyFromModel,
@NonNull final TimestampProvider timestampProvider); Cache(@NonNull final Function<Value, Key> extractKeyFromModel,
@NonNull final TimestampProvider timestampProvider,
final long timeoutMs); private Cache(@NonNull final Function<Value, Key> extractKeyFromModel,
@NonNull final TimestampProvider timestampProvider,
@NonNull final Option<Long> timeoutMs); @Override void putSingular(@NonNull Value value); @Override void putAll(@NonNull List<Value> values); @Override @NonNull Maybe<Value> getSingular(@NonNull final Key key); @Override @NonNull Maybe<List<Value>> getAll(); @Override void clear(); }### Answer:
@Test public void getAllCompletesWithNoEmissionsWhenCacheIsEmpty() { cache.getAll().test().assertNoValues(); } |
### Question:
UnwrapOptionTransformer implements ObservableTransformer<Option<T>, T> { @Override public ObservableSource<T> apply(final Observable<Option<T>> upstream) { return upstream.filter(Option::isSome) .map(OptionUnsafe::getUnsafe); } @Override ObservableSource<T> apply(final Observable<Option<T>> upstream); static UnwrapOptionTransformer<T> create(); }### Answer:
@Test public void transformerFiltersOutNone() { Observable<Option<Object>> source = Observable.just(Option.none()); TestObserver<Object> ts = new TestObserver<>(); transformer.apply(source).subscribe(ts); ts.assertNoValues(); }
@Test public void transformerUnwrapsSome() { Object object = new Object(); Observable<Option<Object>> source = Observable.just(Option.ofObj(object)); TestObserver<Object> ts = new TestObserver<>(); transformer.apply(source).subscribe(ts); ts.assertValue(object); } |
### Question:
Preconditions { public static <T> T checkNotNull(final T reference) { if (reference == null) { throw new NullPointerException(); } return reference; } private Preconditions(); @NonNull static T get(@Nullable final T reference); static T checkNotNull(final T reference); static T checkNotNull(final T reference, @NonNull final String errorMessage); }### Answer:
@Test public void checkNotNull_doesNotThrowException_whenNonNull() { Preconditions.checkNotNull(new Object()); }
@Test public void checkNotNull_throwsNullPointerException_whenNull() { thrown.expect(NullPointerException.class); Preconditions.checkNotNull(null); }
@Test public void checkNotNullWithMessage_doesNotThrowException_whenNonNull() { Preconditions.checkNotNull(new Object(), "Unused message"); }
@Test public void checkNotNullWithMessage_throwsNullPointerExceptionWithMessage_whenNull() { final String message = "message"; thrown.expect(NullPointerException.class); thrown.expectMessage(message); Preconditions.checkNotNull(null, message); } |
### Question:
Preconditions { @NonNull public static <T> T get(@Nullable final T reference) { if (reference == null) { throw new NullPointerException("Assertion for a nonnull object failed."); } return reference; } private Preconditions(); @NonNull static T get(@Nullable final T reference); static T checkNotNull(final T reference); static T checkNotNull(final T reference, @NonNull final String errorMessage); }### Answer:
@Test public void get_returnsParameter_whenNonNull() { Object obj = new Object(); assertThat(Preconditions.get(obj)).isEqualTo(obj); }
@Test public void get_throwsNullPointerException_whenNull() { thrown.expect(NullPointerException.class); Preconditions.get(null); } |
### Question:
StringUtils { @SuppressWarnings("unchecked") @NonNull public String applySubstitutionsToString(@NonNull final String string, @NonNull final Pair<String, String>... substitutions) { String primaryString = string; for (final Pair<String, String> substitution : substitutions) { primaryString = primaryString.replace("{{" + substitution.first + "}}", substitution.second); } return primaryString; } @Inject StringUtils(); @SuppressWarnings("unchecked") @NonNull String applySubstitutionsToString(@NonNull final String string, @NonNull final Pair<String, String>... substitutions); }### Answer:
@Test public void parametersAreReplacedCorrectly() { String param1Name = "firstName"; String param1Value = "Georgy"; String param2Name = "lastName"; String param2Value = "Georgiev"; String string = "He is {{firstName}} {{lastName}}"; String formattedString = stringUtils.applySubstitutionsToString(string, Pair.create(param1Name, param1Value), Pair.create(param2Name, param2Value)); assertThat(formattedString).isEqualTo("He is Georgy Georgiev"); }
@Test public void notFoundParametersAreIgnored() { String param1Name = "wrongParamName"; String param1Value = "Somebody"; String string = "He is {{firstName}}"; String formattedString = stringUtils.applySubstitutionsToString(string, Pair.create(param1Name, param1Value)); assertThat(formattedString).isEqualTo(string); } |
### Question:
ListUtils { @NonNull public static <T> List<T> union(@NonNull final List<T> list1, @NonNull final List<T> list2) { return new ArrayList<T>() {{ addAll(list1); addAll(list2); }}; } @NonNull static List<T> union(@NonNull final List<T> list1, @NonNull final List<T> list2); static boolean isNotEmpty(@NonNull final List<T> list); }### Answer:
@Test public void unionResultsInSecondListAppendedToFirstListRespectingTheOrder() { final List<Object> list1 = new ArrayList<Object>() {{ add(mockObject1); add(mockObject2); add(mockObject3); add(mockObject4); }}; final List<Object> list2 = new ArrayList<Object>() {{ add(mockObject5); add(mockObject6); }}; final List<Object> result = ListUtils.union(list1, list2); Assertions.assertThat(result).containsExactly(mockObject1, mockObject2, mockObject3, mockObject4, mockObject5, mockObject6); }
@Test public void unionDoesNotRemoveDuplicates() { final List<Object> list1 = new ArrayList<Object>() {{ add(mockObject5); add(mockObject6); }}; final List<Object> list2 = new ArrayList<Object>() {{ add(mockObject5); add(mockObject6); }}; final List<Object> result = ListUtils.union(list1, list2); Assertions.assertThat(result).containsExactly(mockObject5, mockObject6, mockObject5, mockObject6); } |
### Question:
ODFValidatorService implements Validate { public ServiceDescription describe() { ServiceDescription.Builder mds = new ServiceDescription.Builder(NAME, Validate.class.getCanonicalName()); mds.description("A validator for ODF file, based on the ODF Toolkit project ODF Validator."); mds.author("Andrew Jackson <[email protected]>"); try { mds.furtherInfo(new URI("http: } catch (URISyntaxException e) { } mds.classname(this.getClass().getCanonicalName()); return mds.build(); } ServiceDescription describe(); ValidateResult validate(DigitalObject dob, URI format, List<Parameter> parameters); static final String NAME; }### Answer:
@Test public void testDescribe() { ServiceDescription desc = ids.describe(); System.out.println("Recieved service description: " + desc.toXmlFormatted() ); assertTrue("The ServiceDescription should not be NULL.", desc != null ); } |
### Question:
ODFValidatorService implements Validate { public ValidateResult validate(DigitalObject dob, URI format, List<Parameter> parameters) { return ODFValidatorWrapper.validateODF(dob,format); } ServiceDescription describe(); ValidateResult validate(DigitalObject dob, URI format, List<Parameter> parameters); static final String NAME; }### Answer:
@Test public void testValidate() throws MalformedURLException, URISyntaxException { testValidateThis(new DigitalObject.Builder( Content.byValue(new File("tests/test-files/documents/test_odt/v11/test_file_v11.odt") ) ).build() , new URI("planets:fmt/ext/odf"), true); testValidateThis(new DigitalObject.Builder( Content.byReference(new File("PC/odf-toolkit/src/test/resources/HelloWorld.doc") ) ).build() , new URI("planets:fmt/ext/odf"), true); testValidateThis(new DigitalObject.Builder( Content.byReference(new File("PC/odf-toolkit/src/test/resources/HelloWorld.sxw") ) ).build() , new URI("planets:fmt/ext/odf"), false); testValidateThis(null, new URI("http: testValidateThis(new DigitalObject.Builder( Content.byReference(new URL("http: true); } |
### Question:
ToolSpec { String toXMlFormatted() throws JAXBException, UnsupportedEncodingException { Marshaller m = jc.createMarshaller(); m.setProperty( Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE ); ByteArrayOutputStream bos = new ByteArrayOutputStream(); m.marshal(this, bos); return bos.toString("UTF-8"); } String getTool(); void setTool(String tool); Version getVersion(); void setVersion(Version version); Install getInstall(); void setInstall(Install install); List<Var> getEnv(); void setEnv(List<Var> env); List<Var> getVar(); void setVar(List<Var> var); List<Convert> getConvert(); void setConvert(List<Convert> convert); List<Validate> getValidate(); void setValidate(List<Validate> validate); static ToolSpec fromInputStream( InputStream input ); }### Answer:
@Test public void testToXMlFormatted() { fail("Not yet implemented"); } |
### Question:
ToolSpec { public static ToolSpec fromInputStream( InputStream input ) throws FileNotFoundException, JAXBException { Unmarshaller u = jc.createUnmarshaller(); return (ToolSpec) u.unmarshal(new StreamSource(input)); } String getTool(); void setTool(String tool); Version getVersion(); void setVersion(Version version); Install getInstall(); void setInstall(Install install); List<Var> getEnv(); void setEnv(List<Var> env); List<Var> getVar(); void setVar(List<Var> var); List<Convert> getConvert(); void setConvert(List<Convert> convert); List<Validate> getValidate(); void setValidate(List<Validate> validate); static ToolSpec fromInputStream( InputStream input ); }### Answer:
@Test public void testFromInputstream() throws FileNotFoundException, JAXBException { ToolSpec kakadu = ToolSpec.fromInputStream( ToolSpec.class.getResourceAsStream("/toolspecs/kakadu.ptspec")); System.out.println("Tools "+kakadu.getTool()); ToolSpec jhove2 = ToolSpec.fromInputStream( ToolSpec.class.getResourceAsStream("/toolspecs/jhove2.ptspec")); System.out.println("Tools "+jhove2.getTool()); ToolSpec isobuster = ToolSpec.fromInputStream( ToolSpec.class.getResourceAsStream("/toolspecs/isobuster.ptspec")); System.out.println("Tools "+isobuster.getTool()); } |
### Question:
PlanetsCommand { public static void main(String[] args) { java.util.logging.Logger.getAnonymousLogger().setLevel(java.util.logging.Level.FINEST); java.util.logging.Logger.getLogger( com.sun.xml.ws.util.Constants.LoggingDomain).setLevel(java.util.logging.Level.FINEST); URL wsdl; try { wsdl = new URL( args[0] ); } catch (MalformedURLException e) { e.printStackTrace(); return; } PlanetsServiceExplorer pse = new PlanetsServiceExplorer( wsdl ); System.out.println(".describe(): "+pse.getServiceDescription()); Service service = Service.create(wsdl, pse.getQName()); PlanetsService ps = (PlanetsService) service.getPort(pse.getServiceClass()); SOAPBinding binding = (SOAPBinding)((BindingProvider)ps).getBinding(); System.out.println("Logging MTOM="+binding.isMTOMEnabled()); ((BindingProvider)ps).getRequestContext().put( JAXWSProperties.MTOM_THRESHOLOD_VALUE, 8192); ((BindingProvider)ps).getRequestContext().put( JAXWSProperties.HTTP_CLIENT_STREAMING_CHUNK_SIZE, 8192); System.out.println("Logging MTOM="+binding.isMTOMEnabled()); binding.setMTOMEnabled(true); System.out.println("Logging MTOM="+binding.isMTOMEnabled()); if( pse.getQName().equals( Migrate.QNAME ) ) { System.out.println("Is a Migrate service. "); Migrate s = MigrateWrapper.createWrapper(wsdl); DigitalObject dobIn = new DigitalObject.Builder(Content.byReference( new File(args[1]))).build(); MigrateResult result = s.migrate(dobIn, URI.create(args[2]), URI.create(args[3]), null); System.out.println("ServiceReport: "+result.getReport()); DigitalObjectUtils.toFile( result.getDigitalObject(), new File("output" ) ); } else if( pse.getQName().equals( Identify.QNAME ) ) { System.out.println("Is an Identify service. "); Identify s = new IdentifyWrapper(wsdl); DigitalObject dobIn = new DigitalObject.Builder(Content.byReference( new File(args[1]))).build(); IdentifyResult result = s.identify(dobIn, null); System.out.println("ServiceReport: "+result.getReport()); } } static void main(String[] args); }### Answer:
@Test public void testMain() { String[] testbedTest = { "http: "tests/test-files/images/bitmap/test_png/png_small/2274192346_4a0a03c5d6.png", "planets:fmt/ext/png", "planets:fmt/ext/jpg"}; PlanetsCommand.main(testbedTest); System.out.println("---- TEST -------------------------------------------------------------------------------------"); String[] dialogikaTest = { "http: "tests/test-files/documents/test_word_6.0/SETUP.DOC", "planets:fmt/ext/doc", "planets:fmt/ext/docx"}; PlanetsCommand.main(dialogikaTest); } |
### Question:
PivotalTrackerUtil { public String pivotalTrackerAdd( String url, String projectId, String token, String name, String storyType, String description) { PivotalTrackerAPI pivotalTrackerTarget = webAPIResolver.getWebAPI(url, PivotalTrackerAPI.class); PivotalTrackerResponse bugData = pivotalTrackerTarget.addBug( token, projectId, MapBuilder.<String, String>newHashMap() .with("name", name) .with("story_type", storyType) .with("description", description) .build()); log.info("Bug Report url = " + bugData.url); return bugData.url; } PivotalTrackerUtil(WebAPIResolver resolver); String pivotalTrackerAdd(
String url,
String projectId,
String token,
String name,
String storyType,
String description); }### Answer:
@Test public void testPivotalTracker() { PivotalTrackerUtil pivotalTrackerUtil = new PivotalTrackerUtil(new MyWebAPIResolver()); final String pivotalTrackerData = pivotalTrackerUtil.pivotalTrackerAdd( "https: "2016043", "ff33d6e6e138d66834a52be6bf19f6f1", "Best Awesome Bug", "bug", "The most awesome ever test of adding bug"); Assert.assertEquals("https: } |
### Question:
Pair implements Serializable { public K getObject1() { return key; } Pair(K key, V value); K getKey(); void setKey(K key); V getValue(); void setValue(V value); K getObject1(); V getObject2(); @Override int hashCode(); @SuppressWarnings("rawtypes") @Override boolean equals(Object obj); @Override String toString(); }### Answer:
@Test public void testObject1() throws Exception { final Pair<String, String> pair1 = new Pair("A", "D"); assertTrue(pair1.getObject1() instanceof String); assertTrue("A".equalsIgnoreCase(pair1.getObject1())); } |
### Question:
Pair implements Serializable { public V getObject2() { return value; } Pair(K key, V value); K getKey(); void setKey(K key); V getValue(); void setValue(V value); K getObject1(); V getObject2(); @Override int hashCode(); @SuppressWarnings("rawtypes") @Override boolean equals(Object obj); @Override String toString(); }### Answer:
@Test public void testObject2() throws Exception { final Pair<String, String> pair1 = new Pair("A", "D"); assertTrue(pair1.getObject2() instanceof String); assertTrue("D".equalsIgnoreCase(pair1.getObject2())); } |
### Question:
Pair implements Serializable { @Override public String toString() { StringBuilder builder = new StringBuilder(); builder.append(key); builder.append(':'); builder.append(value); return builder.toString(); } Pair(K key, V value); K getKey(); void setKey(K key); V getValue(); void setValue(V value); K getObject1(); V getObject2(); @Override int hashCode(); @SuppressWarnings("rawtypes") @Override boolean equals(Object obj); @Override String toString(); }### Answer:
@Test public void testToString() throws Exception { final Pair<String, String> pair = new Pair("Key", "Value"); assertEquals("Key:Value", pair.toString()); } |
### Question:
VariableTime implements IVariableTime { public VariableTime( Integer minute, Integer hour, Integer dayOfWeek, Integer dayOfMonth, Integer month, Integer year) { this.minute = minute; this.hour = hour; this.dayOfWeek = dayOfWeek; this.dayOfMonth = dayOfMonth; this.month = month; this.year = year; } VariableTime(
Integer minute,
Integer hour,
Integer dayOfWeek,
Integer dayOfMonth,
Integer month,
Integer year); Integer getDayOfMonth(); Integer getDayOfWeek(); Integer getYear(); Integer getMonth(); Integer getHour(); Integer getMinute(); }### Answer:
@Test public void testVariableTime() { final VariableTime vt = new VariableTime(20, 4, 3, 4, 12, 1972); assertTrue(vt.getMinute() == 20); assertTrue(vt.getHour() == 4); assertTrue(vt.getDayOfWeek() == 3); assertTrue(vt.getDayOfMonth() == 4); assertTrue(vt.getMonth() == 12); assertTrue(vt.getYear() == 1972); } |
### Question:
CronSchedules { public static String generateDailySchedule() { return random.nextInt(60) + " " + random.nextInt(60) + " " + random.nextInt(24) + " * * ? *"; } private CronSchedules(); static String generateDailySchedule(); static String generateDailySchedule(int startHour, int endHour); }### Answer:
@Test public void testGenerateDefaultDailySchedule() throws Exception { String cron = CronSchedules.generateDailySchedule(); testCommon(cron); String otherCron = CronSchedules.generateDailySchedule(); assertNotEquals(otherCron, cron); }
@Test public void testGenerateDailyScheduleInBounds() throws Exception { int startHour = 10; int endHour = 12; List<Integer> expectedHours = Arrays.asList(10, 11); String cron = CronSchedules.generateDailySchedule(startHour, endHour); testCommon(cron); testBounds(cron, expectedHours); String otherCron = CronSchedules.generateDailySchedule(); assertNotEquals(otherCron, cron); }
@Test public void testGenerateDailyScheduleInDifferentDaysBounds() throws Exception { int startHour = 22; int endHour = 5; List<Integer> expectedHours = Arrays.asList(22, 23, 0, 1, 2, 3, 4); String cron = CronSchedules.generateDailySchedule(startHour, endHour); testCommon(cron); testBounds(cron, expectedHours); String otherCron = CronSchedules.generateDailySchedule(); assertNotEquals(otherCron, cron); }
@Test(expected = IllegalArgumentException.class) public void testStartHourEqualsEndHour() throws Exception { CronSchedules.generateDailySchedule(5, 5); }
@Test(expected = IllegalArgumentException.class) public void testIncorrectStartHour() throws Exception { CronSchedules.generateDailySchedule(25, 3); }
@Test(expected = IllegalArgumentException.class) public void testIncorrectEndHour() throws Exception { CronSchedules.generateDailySchedule(8, -1); } |
### Question:
PrettyDuration { public static String prettyDuration(long milliseconds) { long minutes = TimeUnit.MILLISECONDS.toMinutes(milliseconds); milliseconds -= TimeUnit.MINUTES.toMillis(minutes); long seconds = TimeUnit.MILLISECONDS.toSeconds(milliseconds); milliseconds -= TimeUnit.SECONDS.toMillis(seconds); StringBuilder sb = new StringBuilder(); sb.append(minutes); sb.append("m "); sb.append(seconds); sb.append("s "); sb.append(milliseconds); sb.append("ms"); return (sb.toString()); } static String prettyDuration(long milliseconds); }### Answer:
@Test public void testPrettyDuration() throws Exception { assertEquals("0m 1s 0ms", PrettyDuration.prettyDuration(1000)); } |
### Question:
MurmurHash { public static int hash32(final byte[] data, int length, int seed) { final int m = 0x5bd1e995; final int r = 24; int h = seed ^ length; int length4 = length / 4; for (int i = 0; i < length4; i++) { final int i4 = i * 4; int k = (data[i4 + 0] & 0xff) + ((data[i4 + 1] & 0xff) << 8) + ((data[i4 + 2] & 0xff) << 16) + ((data[i4 + 3] & 0xff) << 24); k *= m; k ^= k >>> r; k *= m; h *= m; h ^= k; } switch (length % 4) { case 3: h ^= (data[(length & ~3) + 2] & 0xff) << 16; case 2: h ^= (data[(length & ~3) + 1] & 0xff) << 8; case 1: h ^= (data[length & ~3] & 0xff); h *= m; default: } h ^= h >>> 13; h *= m; h ^= h >>> 15; return h; } private MurmurHash(); static int hash32(final byte[] data, int length, int seed); static int hash32(final byte[] data, int length); static int hash32(final String text); static int hash32(final String text, int from, int length); static long hash64(final byte[] data, int length, int seed); static long hash64(final byte[] data, int length); static long hash64(final String text); static long hash64(final String text, int from, int length); static long hash64(String first, String... rest); }### Answer:
@Test public void testHash32ByteArrayIntInt() { for (int i = 0; i < input.length; i++) { int hash = MurmurHash.hash32(input[i], input[i].length, 0x71b4954d); if (hash != results32_seed[i]) { fail(String.format( "Unexpected hash32 result for example %d: 0x%08x instead of 0x%08x", i, hash, results32_seed[i])); } } }
@Test public void testHash32ByteArrayInt() { for (int i = 0; i < input.length; i++) { int hash = MurmurHash.hash32(input[i], input[i].length); if (hash != results32_standard[i]) { fail(String.format( "Unexpected hash32 result for example %d: 0x%08x instead of 0x%08x", i, hash, results32_standard[i])); } } }
@Test public void testHash32String() { int hash = MurmurHash.hash32(text); assertTrue(hash == 0xb3bf597e); }
@Test public void testHash32StringIntInt() { int hash = MurmurHash.hash32(text, 2, text.length() - 4); assertTrue(hash == 0x4d666d90); } |
### Question:
SqlBuilder { public String getSqlString() { return command + (command.equals(DELETE) ? "" : selection) + FROM + tableName + getWhereClauseString() + getQuerySuffixString(); } SqlBuilder(String tableName); SqlBuilder(String tableName, String command); static String getSortOrderString(SqlQueryOrder.SortOrder sortOrder); SqlBuilder addCaseInsensitiveLikeCondition(String fieldName, String fieldValue); SqlBuilder addInCondition(String fieldName, Collection<String> values); SqlBuilder addMultipleOrConditionOfKeyValuePairs(
String keyColumnName,
String valueColumnName,
Map<String, String> keyValuePairs); SqlBuilder addCondition(String condition); SqlBuilder addQueryParam(Object param); SqlBuilder addQueryParams(Collection<Object> params); String getSqlString(); SqlBuilder setSelection(String selection); SqlBuilder addQuerySuffix(String querySuffix); SqlBuilder addQuerySuffixWithParam(String suffix, Object param); @NoJavadoc // TODO add JavaDoc SqlBuilder addOrderByClause(SqlQueryOrder sqlQueryOrder); List<Object> getQueryParams(); @Override String toString(); String build(); static final int MAX_ITEMS_FOR_IN_CLAUSE; static final String SELECT; static final String DELETE; }### Answer:
@Test public void testSimpleQuery() { SqlBuilder builder = new SqlBuilder("table"); Assert.assertEquals("wrong query", "select * from table", builder.getSqlString()); } |
### Question:
PersistentMessagingServer implements Connection { @Override public void pause() { queues.values().forEach(Queue::pause); } PersistentMessagingServer(MessagePersister persister); @Override void createQueue(
String queueName,
int memoryBufferMaxMessages,
int secondsToSleepBetweenMessageRetries,
int maxRetries); @Override void sendMessage(String queueName, InputStream messageBody, Map<String, String> headers); @Override void sendMessage(String queueName, Consumer<OutputStream> writer, Map<String, String> headers); @Override void subscribe(String queueName, String consumerName, Consumer<Message> messageConsumer); @Override void unsubscribe(String queueName, String consumerName); @Override void pause(); @Override void pause(String queueName); @Override void start(); @Override void start(String queueName); }### Answer:
@Test public void testPause() throws InterruptedException { Connection connection = createConnectionWithQueue(1000, 2, 1); AtomicInteger count = createSomeMessyQueues(connection); Thread.sleep(55L); connection.pause(); int countRightAfterPause = count.get(); System.out.println(countRightAfterPause); Thread.sleep(100L); System.out.println(count.get()); int countNow = count.get(); Assert.assertTrue("Messages should be drained from the queue", countNow > countRightAfterPause); Thread.sleep(100L); Assert.assertEquals("Messages should stopped being consumed as the queue is paused now", countNow, count.get()); Assert.assertTrue(countNow > 0 && countNow < 10000); } |
### Question:
PersistentMessagingServer implements Connection { @Override public void unsubscribe(String queueName, String consumerName) { getQueue(queueName).removeConsumer(consumerName); } PersistentMessagingServer(MessagePersister persister); @Override void createQueue(
String queueName,
int memoryBufferMaxMessages,
int secondsToSleepBetweenMessageRetries,
int maxRetries); @Override void sendMessage(String queueName, InputStream messageBody, Map<String, String> headers); @Override void sendMessage(String queueName, Consumer<OutputStream> writer, Map<String, String> headers); @Override void subscribe(String queueName, String consumerName, Consumer<Message> messageConsumer); @Override void unsubscribe(String queueName, String consumerName); @Override void pause(); @Override void pause(String queueName); @Override void start(); @Override void start(String queueName); }### Answer:
@Test public void testUnsubscribe() throws InterruptedException { Connection connection = createConnectionWithQueue(1000, 2, 1); AtomicInteger count = createSomeMessyQueues(connection); Thread.sleep(55L); IntStream.range(0,30).forEach((i) -> connection.unsubscribe("q1", "Saruman" + i)); int countRightAfterPause = count.get(); System.out.println(countRightAfterPause); Thread.sleep(100L); System.out.println(count.get()); int countNow = count.get(); Assert.assertTrue("Messages should be drained from the queue until finished un-subscribing", countNow > countRightAfterPause); Thread.sleep(100L); Assert.assertEquals("Messages should stopped being consumed as the queue is has no subscribersnow", countNow, count.get()); Assert.assertTrue(countNow > 0 && countNow < 10000); } |
### Question:
Task { @Override public String toString() { return "Task{" + "id=" + id + ", name='" + name + '\'' + ", executionTime=" + executionTime + ", payload='" + payload + '\'' + '}'; } Task(
String id,
String name,
long executionTime,
String payload); private Task(); final String getId(); final String getName(); final long getExecutionTime(); void setExecutionTime(long executionTime); final String getPayload(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void serializeDeserializeTaskTest() throws Exception { Task task = new Task(UUID.randomUUID().toString(), "task", System.currentTimeMillis(), "payload"); Object serializedTask = PostgresUtil.objectToJsonBParameter(task, null); Task deserializedTask = PostgresUtil.fromJsonB(((PGobject) serializedTask).getValue(), Task.class); Assert.assertEquals(task, deserializedTask); }
@Test public void serializeDeserializeOneOffTaskTest() throws Exception { String id = UUID.randomUUID().toString(); OneOffTask task = new OneOffTask(id, "task", System.currentTimeMillis(), "payload", "consumer"); Object serializedTask = PostgresUtil.objectToJsonBParameter(task, null); Task deserializedTask = PostgresUtil.fromJsonB(((PGobject) serializedTask).getValue(), Task.class); Assert.assertEquals(task, deserializedTask); }
@Test public void serializeDeserializeRecurringTaskTest() throws Exception { String id = UUID.randomUUID().toString(); Task task = new RecurringTask(id, "task", System.currentTimeMillis(), "payload", "function", 5); Object serializedTask = PostgresUtil.objectToJsonBParameter(task, null); Task deserializedTask = PostgresUtil.fromJsonB(((PGobject) serializedTask).getValue(), Task.class); Assert.assertEquals(task, deserializedTask); } |
### Question:
DockerArtifactRegistryImpl implements ArtifactRegistryApi { @Override public Collection<String> listVersions(String artifactId) { try { if (!artifactId.contains("/")) { artifactId = "library/" + artifactId; } final String registryUrl = this.url + "/v2/repositories/" + artifactId + "/tags/"; log.info("fetching tags from {}", registryUrl); final Map res = webAPIResolver .getWebTarget(registryUrl) .request(MediaType.APPLICATION_JSON_TYPE) .buildGet() .invoke(Map.class); return ((List<Map>) res.get("results")) .stream() .map(o -> (String) o.get("name")) .collect(Collectors.toList()); } catch (Exception ex) { log.warn("oh well.. couldn't fetch from registry" + ex.getMessage(), ex); return Collections.singleton("latest"); } } DockerArtifactRegistryImpl(WebAPIResolver webAPIResolver, String url, String username, String password); @Override Collection<String> listVersions(String artifactId); }### Answer:
@Test public void testMe() { new ResteasyJackson2Provider(); final DockerArtifactRegistryImpl dockerArtifactRegistry = new DockerArtifactRegistryImpl(new TestResolver(), "https: final Collection<String> mysql = dockerArtifactRegistry.listVersions("mysql"); mysql.forEach(System.out::println); Assert.assertTrue(mysql.contains("latest")); } |
### Question:
ApplicationCopyEventRepositoryImpl implements ApplicationCopyEventRepository, ServiceLifecycle { @Override public List<ApplicationCopyEvent> listOrderedEvents(UUID copyId) { return nqs.getList(SQL_SELECT_EVENTS_BY_APP_COPY_ID, this::convertRow, Collections.singletonList(copyId)); } ApplicationCopyEventRepositoryImpl(DataSource dataSource); ApplicationCopyEventRepositoryImpl(); @Override UUID subscribe(Consumer<ApplicationCopyEvent> consumer); @Override void unSubscribe(UUID subscriberId); @Override List<ApplicationCopyEvent> listOrderedEvents(UUID copyId); @Override Map<UUID, List<ApplicationCopyEvent>> listByAppInstanceId(UUID appInstanceId); @Override ApplicationCopyEvent store(ApplicationCopyEvent appCopyEvent); @Override Collection<ApplicationCopyEvent> store(Collection<ApplicationCopyEvent> appCopyEvents); @Override void init(Context context); @Override void shutDown(); }### Answer:
@Test public void testNonExistentCopyId() { UUID copyId = UUID.randomUUID(); Collection<ApplicationCopyEvent> events = appCopyEventRepo.listOrderedEvents(copyId); Assert.assertEquals(0, events.size()); } |
### Question:
ApplicationCopyEventRepositoryImpl implements ApplicationCopyEventRepository, ServiceLifecycle { @Override public Map<UUID, List<ApplicationCopyEvent>> listByAppInstanceId(UUID appInstanceId) { return nqs.getMapOfList( SQL_SELECT_EVENTS_BY_APP_INSTANCE_ID, new UuidNativeQueryConverter("appCopyId"), this::convertRow, Collections.singletonList(appInstanceId) ); } ApplicationCopyEventRepositoryImpl(DataSource dataSource); ApplicationCopyEventRepositoryImpl(); @Override UUID subscribe(Consumer<ApplicationCopyEvent> consumer); @Override void unSubscribe(UUID subscriberId); @Override List<ApplicationCopyEvent> listOrderedEvents(UUID copyId); @Override Map<UUID, List<ApplicationCopyEvent>> listByAppInstanceId(UUID appInstanceId); @Override ApplicationCopyEvent store(ApplicationCopyEvent appCopyEvent); @Override Collection<ApplicationCopyEvent> store(Collection<ApplicationCopyEvent> appCopyEvents); @Override void init(Context context); @Override void shutDown(); }### Answer:
@Test public void testNonExistentInstanceId() { UUID instId = UUID.randomUUID(); Map<UUID, List<ApplicationCopyEvent>> events = appCopyEventRepo.listByAppInstanceId(instId); Assert.assertEquals(0, events.keySet().size()); } |
### Question:
SiteRepositoryImpl implements SiteRepository, ServiceLifecycle { @Override public Site load() { final Site site = new Site(siteName); populateSite(site); return site; } SiteRepositoryImpl(); SiteRepositoryImpl(
String siteName,
DataSource dataSource,
SerializationWriter<DbSite> writer,
SerializationReader<DbSite> reader,
ArtifactRegistryFactory artifactRegistryFactory,
WebAPIResolver resolver); @Override void init(Context context); @Override void shutDown(); @Override Site load(); @Override void persist(Site site); }### Answer:
@Test public void testEmptyCreated() { final Site empty = siteRepository.load(); Assert.assertTrue(empty.getCopyRepositories().isEmpty()); Assert.assertTrue(empty.getDsbList().isEmpty()); Assert.assertTrue(empty.getPsbs().isEmpty()); Assert.assertEquals("my-site", empty.getName()); }
@Test public void testAdd() { persistSite(); Site newSite = siteRepository.load(); assertSiteEquals(newSite); } |
### Question:
ErrorsMessageHeaderWriter implements SerializationWriter<ErrorsMessageHeader> { @Override public void writeObject(ErrorsMessageHeader errorsMessageHeader, OutputStream outputStream) throws ErrorMessageHeaderSerializationException { ObjectMapper mapper = new ObjectMapper(); try { mapper.writeValue(outputStream, errorsMessageHeader); } catch (Exception e) { String message = "Could not serialize a List of " + ErrorMessageHeader.class.getName() + " object. Cause: " + e.getMessage(); throw new ErrorMessageHeaderSerializationException(message, e); } } @Override void writeObject(ErrorsMessageHeader errorsMessageHeader, OutputStream outputStream); }### Answer:
@Test public void testWriteListErrorMessageHeader() { List<ErrorMessageHeader> errorMessageHeaders = new ArrayList<>(); errorMessageHeaders.add(new ErrorMessageHeader( "microservice-1-uri", 1456485443905L, 404, "Service 1 unavailable")); errorMessageHeaders.add(new ErrorMessageHeader( "microservice-2-uri", 1456485443906L, 405, "Service 2 unavailable")); errorMessageHeaders.add(new ErrorMessageHeader( "microservice-3-uri", 1456485443907L, 406, "Service 3 unavailable")); errorMessageHeaders.add(new ErrorMessageHeader( "microservice-4-uri", 1456485443908L, 407, "Service 4 unavailable")); ErrorsMessageHeader errorsMessageHeader = new ErrorsMessageHeader(errorMessageHeaders); ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); new ErrorsMessageHeaderWriter().writeObject(errorsMessageHeader, outputStream); String jsonResult = outputStream.toString(); JsonFluentAssert actualJson = JsonFluentAssert.assertThatJson(jsonResult); InputStream expectedJson = getClass().getClassLoader().getResourceAsStream("errors/serialization/errorsmessageheader.json"); String expectedJSON = null; try { expectedJSON = ReadFile.getFileContents(expectedJson).toString(); } catch (IOException e) { e.printStackTrace(); } actualJson.hasSameStructureAs(expectedJSON); actualJson.isEqualTo(expectedJSON); }
@Test public void testException() { ErrorsMessageHeaderWriter writer = new ErrorsMessageHeaderWriter(); try { writer.writeObject(null, null); } catch (ErrorMessageHeaderSerializationException e) { String message = e.getMessage(); Assert.assertTrue(message.startsWith("Could not serialize ")); } } |
### Question:
ErrorMessageHeaderReader implements SerializationReader<ErrorMessageHeader> { @NoJavadoc @Override public ErrorMessageHeader readObject(InputStream inputStream) throws ErrorMessageHeaderSerializationException { ObjectMapper mapper = new ObjectMapper(); try { return mapper.readValue(inputStream, ErrorMessageHeader.class); } catch (Exception e) { String message = "Could not deserialize input into a " + ErrorMessageHeader.class.getName() + " object. Cause: " + e.getMessage(); throw new ErrorMessageHeaderSerializationException(message, e); } } @NoJavadoc @Override ErrorMessageHeader readObject(InputStream inputStream); @NoJavadoc @Override ErrorMessageHeader readObject(Reader reader); @NoJavadoc ErrorMessageHeader readObject(String content); }### Answer:
@Test public void testReadMessageHeaderFromStream() { InputStream inputJsonStream = getClass().getClassLoader().getResourceAsStream("errors/serialization/errormessageheader.json"); ErrorMessageHeader actualErrorMessageHeader = new ErrorMessageHeaderReader().readObject(inputJsonStream); ErrorMessageHeader expectedErrorMessageHeader = new ErrorMessageHeader("microservice-1-uri", 1456485443905L, 404, "Service unavailable"); Assert.assertEquals("Unexpected error message header", expectedErrorMessageHeader, actualErrorMessageHeader); }
@Test public void testReadErrorMessageHeaderFromString() { InputStream inputJsonStream = getClass().getClassLoader().getResourceAsStream("errors/serialization/errormessageheader.json"); String inputJson = null; try { inputJson = ReadFile.getFileContents(inputJsonStream).toString(); } catch (IOException e) { e.printStackTrace(); } ErrorMessageHeader actualErrorMessageHeader = new ErrorMessageHeaderReader().readObject(inputJson); ErrorMessageHeader expectedErrorMessageHeader = new ErrorMessageHeader("microservice-1-uri", 1456485443905L, 404, "Service unavailable"); Assert.assertEquals("Unexpected error message header", expectedErrorMessageHeader, actualErrorMessageHeader); }
@Test public void testException() { InputStream inputStream = null; ErrorMessageHeaderReader reader = new ErrorMessageHeaderReader(); try { reader.readObject(inputStream); } catch (ErrorMessageHeaderSerializationException e) { String message = e.getMessage(); Assert.assertTrue(message.startsWith("Could not deserialize ")); } }
@Test public void testExceptionWithNullContent() { String content = null; ErrorMessageHeaderReader reader = new ErrorMessageHeaderReader(); try { reader.readObject(content); } catch (ErrorMessageHeaderSerializationException e) { String message = e.getMessage(); Assert.assertTrue(message.startsWith("Could not deserialize ")); } } |
### Question:
ErrorMessageHeaderWriter implements SerializationWriter<ErrorMessageHeader> { @Override public void writeObject(ErrorMessageHeader errorMessageHeader, OutputStream outputStream) throws ErrorMessageHeaderSerializationException { ObjectMapper mapper = new ObjectMapper(); try { mapper.writeValue(outputStream, errorMessageHeader); } catch (Exception e) { String message = "Could not serialize a " + ErrorMessageHeader.class.getName() + " object. Cause: " + e.getMessage(); throw new ErrorMessageHeaderSerializationException(message, e); } } @Override void writeObject(ErrorMessageHeader errorMessageHeader, OutputStream outputStream); }### Answer:
@Test public void testWriteErrorMessageHeader() { ErrorMessageHeader errorMessageHeader = new ErrorMessageHeader("microservice-1-uri", 1456485443905L, 404, "Service unavailable"); ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); new ErrorMessageHeaderWriter().writeObject(errorMessageHeader, outputStream); String jsonResult = outputStream.toString(); JsonFluentAssert actualJson = JsonFluentAssert.assertThatJson(jsonResult); InputStream expectedJson = getClass().getClassLoader().getResourceAsStream("errors/serialization/errormessageheader.json"); String expectedJSON = null; try { expectedJSON = ReadFile.getFileContents(expectedJson).toString(); } catch (IOException e) { e.printStackTrace(); } actualJson.hasSameStructureAs(expectedJSON); actualJson.isEqualTo(expectedJSON); }
@Test public void testException() { ErrorMessageHeaderWriter writer = new ErrorMessageHeaderWriter(); try { writer.writeObject(null, null); } catch (ErrorMessageHeaderSerializationException e) { String message = e.getMessage(); Assert.assertTrue(message.startsWith("Could not serialize ")); } } |
### Question:
JiraQueryUtil { public UIJiraLoginResponse queryJira(String url, String userName, String password) { JiraAPI jiraTarget = webAPIResolver.getWebAPI(url, JiraAPI.class); JiraSession session = jiraTarget.autenticate( MapBuilder.<String, String>newHashMap() .with("username", userName) .with("password", password) .build()) .session; if (!"JSESSIONID".equals(session.name)) { throw new InternalServerErrorException("jira session not identified by JSESSIONID but by " + session.name); } return new UIJiraLoginResponse( jiraTarget.listProjects(session.value).stream() .map(o -> new UIJiraLoginResponseProjects(o.id, o.name)) .collect(Collectors.toList()), jiraTarget.listIssueTypes(session.value).stream() .map(o -> new UIJiraLoginResponseProjects(o.id, o.name)) .collect(Collectors.toList()) ); } JiraQueryUtil(WebAPIResolver resolver); UIJiraLoginResponse queryJira(String url, String userName, String password); }### Answer:
@Test public void testJiraQuery() { JiraQueryUtil jiraQueryUtil = new JiraQueryUtil(new MyWebAPIResolver()); final UIJiraLoginResponse jiraData = jiraQueryUtil.queryJira("http: Assert.assertEquals(1, jiraData.getIssueTypes().size()); Assert.assertEquals("iId", jiraData.getIssueTypes().iterator().next().getId()); Assert.assertEquals("iName", jiraData.getIssueTypes().iterator().next().getName()); Assert.assertEquals(1, jiraData.getProjects().size()); Assert.assertEquals("pId", jiraData.getProjects().iterator().next().getId()); Assert.assertEquals("pName", jiraData.getProjects().iterator().next().getName()); }
@Test public void testInvalidSession() { JiraQueryUtil jiraQueryUtil = new JiraQueryUtil(new MyWebAPIResolver(false)); try { jiraQueryUtil.queryJira("http: Assert.fail("Should have failed"); } catch (InternalServerErrorException ex) { } } |
### Question:
ErrorsMessageHeaderReader implements SerializationReader<ErrorsMessageHeader> { @Override public ErrorsMessageHeader readObject(InputStream inputStream) throws ErrorMessageHeaderSerializationException { ObjectMapper mapper = new ObjectMapper(); try { return mapper.readValue(inputStream, ErrorsMessageHeader.class); } catch (Exception e) { String message = "Could not deserialize input into a List of " + ErrorMessageHeader.class.getName() + " object. Cause: " + e.getMessage(); throw new ErrorMessageHeaderSerializationException(message, e); } } @Override ErrorsMessageHeader readObject(InputStream inputStream); @Override ErrorsMessageHeader readObject(Reader reader); @NoJavadoc ErrorsMessageHeader readObject(String content); }### Answer:
@Test public void testReadErrorsMessageHeaderFromStream() { InputStream inputJsonStream = getClass().getClassLoader().getResourceAsStream("errors/serialization/errorsmessageheader.json"); ErrorsMessageHeader actualErrorsMessageHeader = new ErrorsMessageHeaderReader().readObject(inputJsonStream); ArrayList<ErrorMessageHeader> expectedErrorMessageHeaders = new ArrayList<>(); expectedErrorMessageHeaders.add(new ErrorMessageHeader( "microservice-1-uri", 1456485443905L, 404, "Service 1 unavailable")); expectedErrorMessageHeaders.add(new ErrorMessageHeader( "microservice-2-uri", 1456485443906L, 405, "Service 2 unavailable")); expectedErrorMessageHeaders.add(new ErrorMessageHeader( "microservice-3-uri", 1456485443907L, 406, "Service 3 unavailable")); expectedErrorMessageHeaders.add(new ErrorMessageHeader( "microservice-4-uri", 1456485443908L, 407, "Service 4 unavailable")); ErrorsMessageHeader expectedErrorsMessageHeader = new ErrorsMessageHeader(expectedErrorMessageHeaders); Assert.assertTrue( "Unexpected error message header", expectedErrorsMessageHeader .getErrorMessageHeaders() .containsAll(actualErrorsMessageHeader.getErrorMessageHeaders())); }
@Test public void testReadErrorsMessageHeaderFromString() { InputStream inputJsonStream = getClass().getClassLoader().getResourceAsStream("errors/serialization/errorsmessageheader.json"); String inputJson = null; try { inputJson = ReadFile.getFileContents(inputJsonStream).toString(); } catch (IOException e) { e.printStackTrace(); } ErrorsMessageHeader actualErrorsMessageHeader = new ErrorsMessageHeaderReader().readObject(inputJson); List<ErrorMessageHeader> expectedErrorMessageHeaders = new ArrayList<>(); expectedErrorMessageHeaders.add(new ErrorMessageHeader( "microservice-1-uri", 1456485443905L, 404, "Service 1 unavailable")); expectedErrorMessageHeaders.add(new ErrorMessageHeader( "microservice-2-uri", 1456485443906L, 405, "Service 2 unavailable")); expectedErrorMessageHeaders.add(new ErrorMessageHeader( "microservice-3-uri", 1456485443907L, 406, "Service 3 unavailable")); expectedErrorMessageHeaders.add(new ErrorMessageHeader( "microservice-4-uri", 1456485443908L, 407, "Service 4 unavailable")); ErrorsMessageHeader expectedErrorsMessageHeader = new ErrorsMessageHeader(expectedErrorMessageHeaders); Assert.assertTrue( "Unexpected error message header", expectedErrorsMessageHeader .getErrorMessageHeaders() .containsAll(actualErrorsMessageHeader.getErrorMessageHeaders())); }
@Test public void testExceptionWithNullInputStream() { InputStream inputStream = null; ErrorsMessageHeaderReader reader = new ErrorsMessageHeaderReader(); try { reader.readObject(inputStream); } catch (ErrorMessageHeaderSerializationException e) { String message = e.getMessage(); Assert.assertTrue(message.startsWith("Could not deserialize ")); } }
@Test public void testExceptionWithNullContent() { String content = null; ErrorsMessageHeaderReader reader = new ErrorsMessageHeaderReader(); try { reader.readObject(content); } catch (ErrorMessageHeaderSerializationException e) { String message = e.getMessage(); Assert.assertTrue(message.startsWith("Could not deserialize ")); } } |
### Question:
PathUtilities { static boolean isValid(String path) { Objects.requireNonNull(path, "Path can't be null"); if ("/".equals(path)) { return true; } if (path.startsWith("/")) { path = path.substring(1); } for (String part : split(path)) { if (!isPathNameValid(part)) { return false; } } return true; } }### Answer:
@Test public void testPathsWithValidCharacters() { assertTrue(PathUtilities.isValid("level1")); assertTrue(PathUtilities.isValid("level-1")); assertTrue(PathUtilities.isValid("level-1/level-2/level3")); assertTrue(PathUtilities.isValid("1/2/a")); }
@Test public void testThatPathWithOnlyHyphenIsInvalid() { assertFalse(PathUtilities.isValid("level1/-/level3")); assertFalse(PathUtilities.isValid("-")); }
@Test public void testThatPathWithSpaceIsInvalid() { assertFalse(PathUtilities.isValid("level 1")); }
@Test public void testThatPathWithNoneAlphaNumericOrHyphenIsInvalid() { assertFalse(PathUtilities.isValid("apple_level")); assertFalse(PathUtilities.isValid("category%23/apple")); }
@Test public void testThatPathStartingWithSeparatorIsValid() { assertTrue(PathUtilities.isValid("/apple/ball")); }
@Test public void testRootPathIsValid() { assertTrue(PathUtilities.isValid("/")); } |
### Question:
InfluxDBJvmTagParser { public static Map<String, String> parse(String jvmTags) throws IllegalArgumentException { if (jvmTags == null || jvmTags.isEmpty()) { return Collections.EMPTY_MAP; } String[] tagValuePairs = jvmTags.split(","); Map<String, String> result = new HashMap<>(); for (String tagValuePair : tagValuePairs) { String[] tagValueSplit = tagValuePair.split("="); if (tagValueSplit.length != 2) { throw new IllegalArgumentException("jvmTags is in an invalid format. " + "Multiple Tag/Value pairs must be delimited by ','. " + "A tag/value pair must be separated with an '='. jvmTag input was '" + jvmTags + "'"); } String tagName = tagValueSplit[0]; if (tagName.isEmpty()) { throw new IllegalArgumentException("A tag name is empty. jvmTag input was '" + jvmTags + "'"); } String value = tagValueSplit[1]; if (value.isEmpty()) { throw new IllegalArgumentException("The tag value for tag name '" + tagName + "' is empty. Full jvmTag input was '" + jvmTags + "'"); } result.put(tagName, value); } return result; } static Map<String, String> parse(String jvmTags); }### Answer:
@Test public void testNullInput() { Assert.assertEquals(Collections.EMPTY_MAP, new InfluxDBJvmTagParser().parse(null)); }
@Test(expected = IllegalArgumentException.class) public void testNoEqualsSign() { InfluxDBJvmTagParser.parse("iDontContainAnEqualsSign"); }
@Test(expected = IllegalArgumentException.class) public void testLeadsWithEqualsSign() { InfluxDBJvmTagParser.parse("=iLeadWithAnEqualsSign"); }
@Test(expected = IllegalArgumentException.class) public void testMultipleEqualsSignsWithNoDelimeter() { InfluxDBJvmTagParser.parse("tag1=value1 tag2=value2"); }
@Test(expected = IllegalArgumentException.class) public void testMultipleEqualsSignsWithIncorrectDelimeter() { InfluxDBJvmTagParser.parse("tag1=value1;tag2=value2"); }
@Test() public void testSingleTag() { Map<String, String> result = InfluxDBJvmTagParser.parse("tag1=value1"); Assert.assertEquals(1, result.size()); Assert.assertEquals("value1", result.get("tag1")); }
@Test() public void testMultipleTags() { Map<String, String> result = InfluxDBJvmTagParser.parse("tag1=value1,tag2=value2,tag3=value3"); Assert.assertEquals(3, result.size()); Assert.assertEquals("value1", result.get("tag1")); Assert.assertEquals("value2", result.get("tag2")); Assert.assertEquals("value3", result.get("tag3")); } |
### Question:
JMSMessage implements Message { @Override public void readMessage(final MessageReader messageReader) { if (blobStoreAPI != null) { BlobStoreLink blobStoreLink; SerializationReader<BlobStoreLink> reader = serializationManager.getReader(BlobStoreLink.class); try (InputStream inputStream = getInputStream(false)) { blobStoreLink = reader.readObject(inputStream); } catch (IOException e) { throw new IllegalStateException(e); } if (blobStoreAPI.isExists(blobStoreLink.getNamespace(), blobStoreLink.getKey())) { blobStoreAPI.readBlob(blobStoreLink.getNamespace(), blobStoreLink.getKey(), in -> { if (gzip) { try (GZIPInputStream gzipInputStream = new GZIPInputStream(in)) { messageReader.read(gzipInputStream); } catch (IOException e) { throw new IllegalStateException(e); } } else { messageReader.read(in); } }); } else { throw new IllegalStateException( "Failed reading message with id (id doesn't exist)" + blobStoreLink.getNamespace() + ':' + blobStoreLink.getKey()); } } else { try (InputStream jmsBytesMessageInputStream = getInputStream(gzip)) { messageReader.read(jmsBytesMessageInputStream); } catch (IOException e) { throw new IllegalStateException(e); } } } JMSMessage(
SerializationManager serializationManager,
javax.jms.Message msg,
BlobStoreAPI blobStoreAPI,
boolean logMessageWhileReading,
boolean gzip); @Override String getMessageHeader(String headerName); @Override Map<String, String> getMessageHeaders(); @Override String getContextValue(String key); @Override Map<String, String> getMessageContext(); @Override void readMessage(final MessageReader messageReader); @Override Object getUnderlyingMessageObject(); @Override T readObject(Class<T> format); }### Answer:
@Test public void testThatWeGetGZipStream() throws Exception { try (ByteArrayOutputStream bstream = new ByteArrayOutputStream()) { try (GZIPOutputStream out = new GZIPOutputStream(bstream)) { out.write("{\"a\":1}".getBytes("UTF-8")); out.finish(); JMSMessage jmsMsg = new JMSMessage( new SerializationManagerImpl(), new TestMessage(bstream.toByteArray()), null, false, true); jmsMsg.readMessage(in -> assertTrue(in instanceof GZIPInputStream)); } } }
@Test public void testThatWeGetLoggingStream() throws Exception { try (ByteArrayOutputStream bstream = new ByteArrayOutputStream()) { try (GZIPOutputStream out = new GZIPOutputStream(bstream)) { out.write("{\"a\":1}".getBytes("UTF-8")); out.finish(); JMSMessage jmsMsg = new JMSMessage( new SerializationManagerImpl(), new TestMessage(bstream.toByteArray()), null, true, true); jmsMsg.readMessage(in -> assertTrue(in instanceof LoggingInputStream)); } } }
@Test public void testThatWeGetNormalStream() throws Exception { Message msg = new TestMessage("{\"a\":1}".getBytes("UTF-8")); JMSMessage jmsMsg = new JMSMessage(new SerializationManagerImpl(), msg, null, true, false); jmsMsg.readMessage(in -> assertFalse(in instanceof GZIPInputStream)); } |
### Question:
SavedImageRepositoryImpl extends AbstractHubRepositoryImpl implements SavedImageRepository, ServiceLifecycle { @Override public Collection<DBSavedImage> list() { return nqs.getList(SQL_SELECT, this::convertRow); } SavedImageRepositoryImpl(); SavedImageRepositoryImpl(DataSource dataSource); @Override void init(Context context); @Override void pause(); @Override void resume(); @Override void shutDown(); @Override DBSavedImage get(UUID savedImageId); @Override Collection<DBSavedImage> findByAppTemplateId(UUID appTemplateId); @Override void add(DBSavedImage savedImage); @Override Collection<DBSavedImage> list(); @Override void updateImageState(UUID savedImageId, DBSavedImage.DBSavedImageState state); }### Answer:
@Test public void testCreate() throws DuplicateResourceException { UUID id = UUID.randomUUID(); final DBSavedImage newImage = createAndVerify(id, "my Image"); final Collection<DBSavedImage> list = savedImageRepository.list(); Assert.assertEquals("Must be exactly one template", 1, list.size()); final DBSavedImage fromList = list.iterator().next(); Assert.assertNotNull(fromList); assertEquals(newImage, fromList); } |
### Question:
SchemaBootstrapScript { @NoJavadoc public Reader getScriptReader() throws IOException { StringReader reader; if (scriptContent != null) { reader = new StringReader(scriptContent.toString()); } else { InputStream resourceAsStream = Objects.requireNonNull( this.getClass().getClassLoader().getResourceAsStream(resourceLocation), "Invalid resource path provided for sql file, resource could not be located: " + resourceLocation); reader = new StringReader(IOUtils.toString(resourceAsStream)); } return reader; } SchemaBootstrapScript(String resourceLocation, String description, int schemaVersion); SchemaBootstrapScript(StringBuilder scriptContent, String description, int schemaVersion); String getDescription(); int getSchemaVersion(); @NoJavadoc Reader getScriptReader(); }### Answer:
@Test public void testGetScriptReaderFromFile() throws Exception { schemaBootstrapScript = new SchemaBootstrapScript("test.sql", "test", 1); final Reader reader = schemaBootstrapScript.getScriptReader(); final List<String> lines = IOUtils.readLines(reader); assertTrue(reader instanceof StringReader); assertTrue(lines.equals(Arrays.asList(EXPECTED.split("\n")))); }
@Test public void testGetScriptReaderFromStringBuilder() throws Exception { final StringBuilder stringBuilder = new StringBuilder(EXPECTED); schemaBootstrapScript = new SchemaBootstrapScript(stringBuilder, "test", 1); final Reader reader = schemaBootstrapScript.getScriptReader(); assertTrue(reader instanceof StringReader); assertEquals(EXPECTED, IOUtils.toString(reader)); } |
### Question:
Timer { public Collection<String> list() { return jobs.keySet(); } Timer(String name, MetricsRegistry registry); void add(String name, Runnable runnable, int seconds, Date nextRun); void add(String name, Runnable runnable, int seconds); void remove(String name); Collection<String> list(); void pause(); void resume(); void stop(); void start(); }### Answer:
@Test public void testThatTimerSupportsAddingTasks() { Assert.assertTrue(timer.list().contains(TASK1)); Assert.assertTrue(timer.list().contains(TASK2)); } |
### Question:
Timer { public void start() { executor.execute(this::process); } Timer(String name, MetricsRegistry registry); void add(String name, Runnable runnable, int seconds, Date nextRun); void add(String name, Runnable runnable, int seconds); void remove(String name); Collection<String> list(); void pause(); void resume(); void stop(); void start(); }### Answer:
@Test public void testThatTasksRunCorrectNumberOfTimes() throws Exception { timer.start(); Thread.sleep(5 * 1000); Assert.assertEquals(3, sensing.get(TASK1).size()); Assert.assertEquals(2, sensing.get(TASK2).size()); }
@Test public void testThatMetricsIsUpdated() throws Exception { timer.start(); Thread.sleep(5 * 1000); Assert.assertEquals(2, registry.getRegistry().getTimers().size()); } |
### Question:
MicroServiceStateResource extends MicroServiceResource implements MicroServiceStateAPI { @Override public ServiceState getServiceState() { Context context = getMicroServiceApplication().getMicroServiceContext(); List<ServiceState.InputQueueState> inputQueues = new ArrayList<>(); ResourceManager<InputQueueDescriptor, InputQueueConfiguration, ManagedInputQueue> queuesManager = context.getQueuesManager(); List<ManagedInputQueue> managedQueuesStats = queuesManager.getManagedResources(); if (!managedQueuesStats.isEmpty()) { for (ManagedInputQueue currManagedQueue : managedQueuesStats) { List<ServiceState.InputQueueReceiver> receivers = new ArrayList<>(); if (!currManagedQueue.getReceivers().isEmpty()) { for (QueueReceiver currReceiver : currManagedQueue.getReceivers()) { QueueExecutionState currState = ((QueueReceiverImpl) currReceiver).getMessageListener().getQueueExecutionState(); QueueExecutionState.ReceiverRunningState state = currState.getState(); Date lastExecutionTime = null; Date currExecutionStartTime = null; Map<String, String> properties = null; switch (state) { case RUNNING: currExecutionStartTime = new Date(currState.getExecutionStartTime()); Map<String, String> headers = currState.getHeaders(); if (!headers.isEmpty()) { properties = new HashMap<>(headers); } break; case IDLE: Long executionEndTime = currState.getExecutionEndTime(); if (executionEndTime != null) { lastExecutionTime = new Date(executionEndTime); } break; default: break; } receivers.add(new ServiceState.InputQueueReceiver( currState.getState().name(), currState.getInitializedDate(), lastExecutionTime, currExecutionStartTime, properties)); } } inputQueues.add(new ServiceState.InputQueueState(currManagedQueue.getQueueName(), receivers)); } } final StaticObjectMetric<RestCallInfo> restCallInfoStaticObjectMetric = context.getMetricsRegistry().getStaticObjectMetric(RestCallInfo.class); final long currentTimeMillis = System.currentTimeMillis(); return new ServiceState( context.getMicroServiceName(), ServiceState.ServiceStateEnum.valueOf(context.getServiceState().name()), context.getLogger().getName(), inputQueues, restCallInfoStaticObjectMetric.list() .stream() .map((i) -> new ServiceState.RestRequestState( i.getMethod(), i.getUrl(), currentTimeMillis - i.getStartTime().getTime())) .collect(Collectors.toList()) ); } @Override ServiceState getServiceState(); }### Answer:
@Test public void getServiceState() throws URISyntaxException, IOException { final MockHttpResponse response = get(MicroServiceStateAPI.BASE_URI, MediaType.APPLICATION_JSON_TYPE); assertEquals(HttpStatus.SC_OK, response.getStatus()); final Map<String, ?> json = json(response); assertEquals("Mock Micro Service", json.get("name")); assertEquals("RUNNING", json.get("state")); } |
### Question:
RabbitMQMessage implements Message { @Override public void readMessage(final MessageReader messageReader) { if (blobstoreApi != null) { BlobStoreLink blobStoreLink = MessagingSerializationHelper.readObject( serializationManager, BlobStoreLink.class, delivery.getBody()); if (blobstoreApi.isExists(blobStoreLink.getNamespace(), blobStoreLink.getKey())) { blobstoreApi.readBlob(blobStoreLink.getNamespace(), blobStoreLink.getKey(), in -> { if (gzip) { try (GZIPInputStream gzipInputStream = new GZIPInputStream(in)) { messageReader.read(gzipInputStream); } catch (IOException e) { throw new IllegalStateException(e); } } else { messageReader.read(in); } }); } else { throw new IllegalStateException( "Failed reading message with id (id doesn't exist)" + blobStoreLink.getNamespace() + ':' + blobStoreLink.getKey()); } } else { byte[] body = delivery.getBody(); try (InputStream stream = getInputStream(body)) { messageReader.read(stream); } catch (IOException e) { throw new IllegalStateException(e); } } } RabbitMQMessage(
SerializationManager serializationManager, QueueingConsumer.Delivery delivery,
BlobStoreAPI blobstoreApi, boolean gzip,
boolean logMessageWhileReading); @Override String getMessageHeader(String headerName); void addErrorMessageHeader(String microserviceURI, long timestamp, int errorCode, String errorMessage); void setFailed(boolean failed); boolean isFailed(); @Override Map<String, String> getMessageHeaders(); @Override Map<String, String> getMessageContext(); @Override String getContextValue(String key); @Override void readMessage(final MessageReader messageReader); @Override Object getUnderlyingMessageObject(); @Override T readObject(Class<T> format); List<XDeath> getXDeaths(); @NoJavadoc static String getNamespace(String blobstoreNamespace, String exchange, String queue); @NoJavadoc AMQP.BasicProperties getProperties(); }### Answer:
@Test public void testThatWeGetGZipStreamForCompressedData() throws Exception { try (ByteArrayOutputStream s = new ByteArrayOutputStream()) { try (GZIPOutputStream out = new GZIPOutputStream(s)) { out.write(data); out.finish(); QueueingConsumer.Delivery delivery = new QueueingConsumer.Delivery(null, null, s.toByteArray()); RabbitMQMessage mqMsg = new RabbitMQMessage(new SerializationManagerImpl(), delivery, null, true, false); mqMsg.readMessage(in -> assertTrue(in instanceof GZIPInputStream)); } } }
@Test public void testThatWeGetNormalStreamForUncompressedData() throws Exception { QueueingConsumer.Delivery delivery = new QueueingConsumer.Delivery(null, null, data); RabbitMQMessage mqMsg = new RabbitMQMessage(new SerializationManagerImpl(), delivery, null, false, false); mqMsg.readMessage(in -> assertFalse(in instanceof GZIPInputStream)); }
@Test public void testThatWeGetLoggingStreamForUncompressedData() throws Exception { QueueingConsumer.Delivery delivery = new QueueingConsumer.Delivery(null, null, data); RabbitMQMessage mqMsg = new RabbitMQMessage(new SerializationManagerImpl(), delivery, null, false, true); mqMsg.readMessage(in -> assertTrue(in instanceof LoggingInputStream)); }
@Test public void testThatWeGetLoggingStreamForCompressedData() throws Exception { try (ByteArrayOutputStream s = new ByteArrayOutputStream()) { try (GZIPOutputStream out = new GZIPOutputStream(s)) { out.write(data); out.finish(); QueueingConsumer.Delivery delivery = new QueueingConsumer.Delivery(null, null, s.toByteArray()); RabbitMQMessage mqMsg = new RabbitMQMessage(new SerializationManagerImpl(), delivery, null, true, true); mqMsg.readMessage(in -> assertTrue(in instanceof LoggingInputStream)); } } } |
### Question:
TempFileSystemBlobStore implements BlobStore { @Override public void moveNameSpace(final String oldNamespace, final String key, final String newNamespace) throws ObjectKeyFormatException, DuplicateObjectKeyException, IllegalStoreStateException { isKeyAcceptable(key); isKeyAcceptable(oldNamespace); isKeyAcceptable(newNamespace); try { File[] files = folder.listFiles(getHeadersFilenameFilter(oldNamespace, key)); ren(files, HEADERS_PREFIX + oldNamespace + "." + key, HEADERS_PREFIX + newNamespace + "." + key + "."); files = folder.listFiles(getFilenameFilter(oldNamespace, key)); ren(files, BLOB_PREFIX + oldNamespace + "." + key, BLOB_PREFIX + newNamespace + "." + key + "."); } catch (IOException e) { throw new IllegalStoreStateException("IOException happened", e); } } TempFileSystemBlobStore(); void create(String namespace, String key, Map<String, String> headers, final InputStream blob); @Override void create(String namespace, String key, Map<String, String> headers, BlobWriter blobWriter); @Override void update(String namespace, String key, Map<String, String> headers, InputStream blob); @Override void update(String namespace, String key, Map<String, String> headers, BlobWriter blobWriter); @Override void moveNameSpace(final String oldNamespace, final String key, final String newNamespace); void ren(File[] files, String target, String replacement); @Override void readBlob(final String namespace, final String key, BlobReader reader); @Override void readBlob(final String namespace, final String key, final OutputStream out); @Override Map<String, String> readHeaders(final String namespace, final String key); @Override void delete(int expirySeconds); @Override void delete(final String namespace, final String key); FilenameFilter getHeadersFilenameFilter(String namespace, String key); FilenameFilter getFilenameFilter(String namespace, String key); @Override boolean isExists(final String namespace, final String key); @Override Collection<BlobStoreLink> list(); }### Answer:
@Test public void testMoveNamespace() throws Exception { HashMap<String, String> headers = new HashMap<>(); headers.put("filename", "brain_slug.png"); headers.put("retention", "1000"); File bsImage = new File(TestTempFileSystemBlobStore.class.getClassLoader().getResource("brain_slug.png").getFile()); BlobStore bs = new TempFileSystemBlobStore(); String key = UUID.randomUUID().toString(); String originalNameSpace = "ashish"; bs.update(originalNameSpace, key, headers, new FileInputStream(bsImage)); Map<String, String> storedHeaders = bs.readHeaders(originalNameSpace, key); assertEquals( "'filename' property doesn't exists or not equals to stored metadata ", "brain_slug.png", storedHeaders.get("filename")); Assert.assertTrue(bs.isExists(originalNameSpace, key)); ByteArrayOutputStream originalByteArrayOutputStream = new ByteArrayOutputStream(); bs.readBlob(originalNameSpace, key, originalByteArrayOutputStream); assertEquals( "Stored file in blob store is not the same as received from blob store", originalByteArrayOutputStream.toByteArray().length, bsImage.length()); String newNamespace = "chen"; bs.moveNameSpace(originalNameSpace, key, newNamespace); Assert.assertTrue(bs.isExists(newNamespace, key)); Assert.assertTrue(bs.isExists(newNamespace, key)); ByteArrayOutputStream newByteArrayOutputStream = new ByteArrayOutputStream(); bs.readBlob(newNamespace, key, newByteArrayOutputStream); assertEquals( "Stored file in blob store is not the same as received from blob store", newByteArrayOutputStream.toByteArray().length, bsImage.length()); Assert.assertFalse(bs.isExists(originalNameSpace, key)); bs.delete(newNamespace, key); } |
### Question:
TempFileSystemBlobStore implements BlobStore { @Override public void update(String namespace, String key, Map<String, String> headers, InputStream blob) throws ObjectKeyFormatException, IllegalStoreStateException { try { delete(namespace, key); create(namespace, key, headers, blob); } catch (DuplicateObjectKeyException e) { log.error( "Duplicate keys happened. most likely something wrong with implementation. " + "This should never happens.", e); } } TempFileSystemBlobStore(); void create(String namespace, String key, Map<String, String> headers, final InputStream blob); @Override void create(String namespace, String key, Map<String, String> headers, BlobWriter blobWriter); @Override void update(String namespace, String key, Map<String, String> headers, InputStream blob); @Override void update(String namespace, String key, Map<String, String> headers, BlobWriter blobWriter); @Override void moveNameSpace(final String oldNamespace, final String key, final String newNamespace); void ren(File[] files, String target, String replacement); @Override void readBlob(final String namespace, final String key, BlobReader reader); @Override void readBlob(final String namespace, final String key, final OutputStream out); @Override Map<String, String> readHeaders(final String namespace, final String key); @Override void delete(int expirySeconds); @Override void delete(final String namespace, final String key); FilenameFilter getHeadersFilenameFilter(String namespace, String key); FilenameFilter getFilenameFilter(String namespace, String key); @Override boolean isExists(final String namespace, final String key); @Override Collection<BlobStoreLink> list(); }### Answer:
@Test public void testIllegalKey() { BlobStore bs = new TempFileSystemBlobStore(); InputStream inputStream = null; try { bs.update(".", "!", null, inputStream); assertTrue("illegal key passed as valid", false); } catch (ObjectKeyFormatException e) { assertTrue(true); } catch (IllegalStoreStateException e) { assertTrue("IllegalStoreStateException should not be thrown", false); } } |
### Question:
ReadFile { public static String getFileContentsFromResource(String resourceLocation) throws IOException { ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); return getFileContentsFromResource(resourceLocation, classLoader); } static String getFileContentsFromResource(String resourceLocation); static String getFileContentsFromResource(String resourceLocation, ClassLoader classLoader); static StringBuilder getFileContentsFromResourceAsStringBuilder(
String resourceLocation,
ClassLoader classLoader); static String getFileContents(File file); static StringBuilder getFileContents(InputStream inputStream); static StringBuilder getFileContents(Reader reader); }### Answer:
@Test(expected = FileNotFoundException.class) public void getFileContentsFromResourceTest() throws IOException { final String result = ReadFile.getFileContentsFromResource(TESTFILE); assertNotNull(result); assertTrue(result.contains("wheezles")); ReadFile.getFileContentsFromResource(BADFILE); assertFalse(true); }
@Test(expected = FileNotFoundException.class) public void getFileContentsFromResourceWithClassloaderTest() throws IOException { final String result = ReadFile.getFileContentsFromResource(TESTFILE, Thread.currentThread().getContextClassLoader()); assertNotNull(result); assertTrue(result.contains("wheezles")); ReadFile.getFileContentsFromResource(BADFILE, Thread.currentThread().getContextClassLoader()); assertFalse(true); } |
### Question:
MicroServiceMetricsResource extends MicroServiceResource implements MicroServiceMetricsAPI { @Override public Response getMetricsOutput() { StreamingOutput stream = outputStream -> mapper .writerWithDefaultPrettyPrinter() .writeValue(outputStream, getMicroServiceApplication().getMicroServiceContext().getMetricsRegistry()); return Response .ok(stream, MediaType.APPLICATION_JSON_TYPE) .header("Cache-Control", "must-revalidate,no-cache,no-store") .build(); } MicroServiceMetricsResource(); @Override Response getMetricsOutput(); @Override Map<String, List> getDsMetrics(@PathParam("ds") String ds); }### Answer:
@Test @SuppressWarnings("unchecked") public void getMetricsOutput() throws URISyntaxException, IOException { final MockHttpResponse response = get(MicroServiceMetricsAPI.BASE_URI, MediaType.APPLICATION_JSON_TYPE); assertEquals(HttpStatus.SC_OK, response.getStatus()); final Map<String, ?> json = json(response); System.out.println(json); assertEquals("mock-api", json.get("name")); final Map<String, ?> metrics = (Map<String, ?>) json.get("metrics"); assertEquals("3.0.0", metrics.get("version")); } |
### Question:
ReadFile { public static StringBuilder getFileContentsFromResourceAsStringBuilder( String resourceLocation, ClassLoader classLoader) throws IOException { InputStream inputStream = classLoader.getResourceAsStream(resourceLocation); if (inputStream == null) { throw new FileNotFoundException("Could not find resource file at path '" + resourceLocation + "'"); } return getFileContents(inputStream); } static String getFileContentsFromResource(String resourceLocation); static String getFileContentsFromResource(String resourceLocation, ClassLoader classLoader); static StringBuilder getFileContentsFromResourceAsStringBuilder(
String resourceLocation,
ClassLoader classLoader); static String getFileContents(File file); static StringBuilder getFileContents(InputStream inputStream); static StringBuilder getFileContents(Reader reader); }### Answer:
@Test public void getFileContentsFromResourceAsStringBuilderTest() throws IOException { final StringBuilder sb = ReadFile.getFileContentsFromResourceAsStringBuilder( TESTFILE, Thread.currentThread().getContextClassLoader()); assertFalse(sb.length() == 0); } |
### Question:
CountingReader extends Reader { @Override public boolean ready() throws IOException { return delegate.ready(); } CountingReader(Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); int getCharCount(); }### Answer:
@Test public void ready() throws IOException { when(delegate.ready()).thenReturn(true); assertTrue(cut.ready()); verify(delegate).ready(); } |
### Question:
CountingReader extends Reader { @Override public boolean markSupported() { return false; } CountingReader(Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); int getCharCount(); }### Answer:
@Test public void markSupported() { assertFalse(cut.markSupported()); } |
### Question:
CountingReader extends Reader { @Override public void mark(int readAheadLimit) throws IOException { throw new IOException("mark() not supported"); } CountingReader(Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); int getCharCount(); }### Answer:
@Test(expected = IOException.class) public void mark() throws IOException { cut.mark(1000); } |
### Question:
CountingReader extends Reader { @Override public void reset() throws IOException { throw new IOException("reset() not supported"); } CountingReader(Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); int getCharCount(); }### Answer:
@Test(expected = IOException.class) public void reset() throws IOException { cut.reset(); } |
### Question:
CountingReader extends Reader { @Override public void close() throws IOException { delegate.close(); } CountingReader(Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); int getCharCount(); }### Answer:
@Test public void close() throws IOException { cut.close(); verify(delegate).close(); } |
### Question:
CountingReader extends Reader { public int getCharCount() { return charCount; } CountingReader(Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); int getCharCount(); }### Answer:
@Test public void getCharCountWithNoCharactersRead() { assertEquals(0, cut.getCharCount()); } |
### Question:
MicroServiceConfigurationResource extends MicroServiceResource implements MicroServiceConfigurationAPI { @Override public ServiceConfiguration getServiceConfiguration() { Context context = getMicroServiceApplication().getMicroServiceContext(); LoggerConfig loggerConfig = getLoggerConfig(context); List<ResourceConfig> inputQueues = getResourceConfigs(context.getQueuesManager().getManagedResources()); List<ResourceConfig> datasources = getResourceConfigs(context.getDatasourceManager().getManagedResources()); List<ResourceConfig> destinations = getResourceConfigs(context.getDestinationManager().getManagedResources()); List<ResourceConfig> blobStores = getResourceConfigs(context.getBlobStoreManager().getManagedResources()); List<ResourceConfig> serviceDependencies = getDependencyConfigs(context.getDependencyManager().getManagedResources()); List<ResourceConfig> externalResources = new ArrayList<>(); for (ResourceManager currExternalResourceManager : context.getExternalResourceManagers()) { externalResources.addAll(getResourceConfigs(currExternalResourceManager.getManagedResources())); } List<ParamConfig> paramsConfig = getParamConfigs(context); return new ServiceConfiguration( context.getMicroServiceName(), context.getServiceDescription(), context.getMicroServiceBaseURI(), loggerConfig, inputQueues, datasources, destinations, blobStores, serviceDependencies, externalResources, paramsConfig ); } @Override ServiceConfiguration getServiceConfiguration(); @Override Response setLogLevel(); }### Answer:
@Test @SuppressWarnings("unchecked") public void getServiceConfiguration() throws URISyntaxException, IOException { final MockHttpResponse response = get(MicroServiceConfigurationAPI.BASE_URI, MediaType.APPLICATION_JSON_TYPE); assertEquals(HttpStatus.SC_OK, response.getStatus()); final Map<String, ?> json = json(response); assertEquals("Mock Micro Service", json.get("name")); assertEquals(VERSION_NOT_AVAILABLE, json.get("version")); final List<Map<String, ?>> parameters = (List<Map<String, ?>>) json.get("parameters"); assertEquals("Expected 2 parameters, boo-timeout and health-check-period-in-seconds", 3, parameters.size()); } |
### Question:
PrefixReader extends Reader { @Override public boolean markSupported() { return false; } PrefixReader(char[] prefix, Reader delegate); PrefixReader(Object lock, char[] prefix, Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); }### Answer:
@Test public void markSupported() throws IOException { assertFalse(cut.markSupported()); } |
### Question:
ManagedMessageListenerImpl implements ManagedMessageListener { private void handleMessage(Message message, Context context, boolean isError) { ContextThreadLocal.setContext(context); Thread currentThread = Thread.currentThread(); String origThreadName = currentThread.getName(); MessageLoggingContext messageLoggingContext = buildMessageLoggingContext(message); Map<String, String> messageHeaderValuesForLogging = messageLoggingContext.getMessageHeaderValuesForLogging(); if (logger.isDebugEnabled()) { logger.debug("currentThread {}", currentThread); logger.debug("origThreadName {}", origThreadName); messageHeaderValuesForLogging.values().forEach(logger::debug); } try (CounterMetric autoCounter = activeJobs.inc(); StopWatch stopWatch = messageProcessingTimer.getStopWatch( new MapMetricState(messageHeaderValuesForLogging))) { queueExecutionState.setExecutionState(messageHeaderValuesForLogging); currentThread.setName(messageLoggingContext.getThreadName()); if (logger.isDebugEnabled()) { logger.debug("Executing message listener"); } if (isError) { handleErrorMessage(message, context); } else { messageListener.onMessage(message, context); } if (logger.isDebugEnabled()) { logger.debug("Done executing message listener"); } } catch (Exception ex) { logger.warn("Error while processing message. {}", ex.getMessage()); errorCounter.inc(); throw ex; } finally { try { queueExecutionState.clearExecutionState(); } finally { currentThread.setName(origThreadName); } } } ManagedMessageListenerImpl(
Context context,
MessageListener messageListener,
ManagedInputQueue managedQueue,
int threadOrdinal); @Override void onMessage(Message message, Context context); @Override void onErrorMessage(Message message, Context context); QueueExecutionState getQueueExecutionState(); }### Answer:
@Test public void testHandleMessage() { Message message = mock(Message.class); managedMessageListener.onMessage(message, context); verify(messageListener).onMessage(eq(message), eq(context)); } |
### Question:
PrefixReader extends Reader { @Override public void mark(int readAheadLimit) throws IOException { throw new IOException("mark() not supported"); } PrefixReader(char[] prefix, Reader delegate); PrefixReader(Object lock, char[] prefix, Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); }### Answer:
@Test(expected = IOException.class) public void mark() throws Exception { cut.mark(0); } |
### Question:
PrefixReader extends Reader { @Override public void reset() throws IOException { throw new IOException("reset() not supported"); } PrefixReader(char[] prefix, Reader delegate); PrefixReader(Object lock, char[] prefix, Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); }### Answer:
@Test(expected = IOException.class) public void reset() throws Exception { cut.reset(); } |
### Question:
PrefixReader extends Reader { @Override public void close() throws IOException { delegate.close(); } PrefixReader(char[] prefix, Reader delegate); PrefixReader(Object lock, char[] prefix, Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); }### Answer:
@Test public void close() throws Exception { final Reader mockDelegate = Mockito.mock(Reader.class); final PrefixReader cut = new PrefixReader(prefix, mockDelegate); cut.close(); verify(mockDelegate).close(); } |
### Question:
PrefixReader extends Reader { @Override public boolean ready() throws IOException { return delegate.ready(); } PrefixReader(char[] prefix, Reader delegate); PrefixReader(Object lock, char[] prefix, Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); }### Answer:
@Test public void ready() throws Exception { final Reader mockDelegate = Mockito.mock(Reader.class); final PrefixReader cut = new PrefixReader(prefix, mockDelegate); cut.ready(); verify(mockDelegate).ready(); } |
### Question:
EscapingReader extends Reader { @Override public int read() throws IOException { int fromDelegate = delegate.read(); if (fromDelegate < 0) { return fromDelegate; } char c = (char) fromDelegate; while (invalidCharsPattern.matcher(String.valueOf(c)).find()) { fromDelegate = delegate.read(); if (fromDelegate < 0) { return fromDelegate; } c = (char) fromDelegate; } return fromDelegate; } EscapingReader(Reader delegate); EscapingReader(Object lock, Reader delegate); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); }### Answer:
@Test public void read() throws IOException { when(mockDelegate.read()).thenReturn((int) 'y', (int) 'a', (int) 'y', -1); assertEquals((int) 'y', cut.read()); assertEquals((int) 'a', cut.read()); assertEquals((int) 'y', cut.read()); assertEquals(-1, cut.read()); }
@Test public void readWithLock() throws IOException { when(mockDelegate.read()).thenReturn((int) 'y', (int) 'a', (int) 'y', -1); final Object lock = new Object(); cut = new EscapingReader(lock, mockDelegate); assertEquals((int) 'y', cut.read()); assertEquals((int) 'a', cut.read()); assertEquals((int) 'y', cut.read()); assertEquals(-1, cut.read()); }
@Test public void readWithIllegalAtEnd() throws IOException { when(mockDelegate.read()).thenReturn((int) 'y', 0x00, -1); assertEquals((int) 'y', cut.read()); assertEquals(-1, cut.read()); }
@Test public void readWithIllegalNotAtEnd() throws IOException { when(mockDelegate.read()).thenReturn((int) 'y', 0x00, (int) 'y', -1); assertEquals((int) 'y', cut.read()); assertEquals((int) 'y', cut.read()); assertEquals(-1, cut.read()); }
@Test public void readWithCharArrayAndDelegateEOF() throws IOException { when(mockDelegate.read((char[]) Mockito.anyVararg(), Mockito.anyInt(), Mockito.anyInt())).thenReturn(-1); final char[] buffer = new char[10]; assertEquals(-1, cut.read(buffer)); }
@Test public void readWithCharArrayAndLegalText() throws IOException { cut = new EscapingReader(new StringReader("legal")); final char[] buffer = new char[10]; assertEquals(5, cut.read(buffer)); assertEquals("legal", String.valueOf(buffer, 0, 5)); }
@Test public void readWithCharArrayAndIllegalText() throws IOException { cut = new EscapingReader(new StringReader("bad\0char")); final char[] buffer = new char[10]; assertEquals(7, cut.read(buffer)); assertEquals("badchar", String.valueOf(buffer, 0, 7)); }
@Test public void readWithCharBufferAndLegalText() throws IOException { cut = new EscapingReader(new StringReader("legal")); final CharBuffer buffer = CharBuffer.allocate(10); assertEquals(5, cut.read(buffer)); buffer.flip(); assertEquals("legal", buffer.toString()); }
@Test public void readWithCharBufferAndIllegalText() throws IOException { cut = new EscapingReader(new StringReader("bad\0char")); final CharBuffer buffer = CharBuffer.allocate(10); assertEquals(7, cut.read(buffer)); buffer.flip(); assertEquals("badchar", buffer.toString()); } |
### Question:
EscapingReader extends Reader { @Override public long skip(long n) throws IOException { return delegate.skip(n); } EscapingReader(Reader delegate); EscapingReader(Object lock, Reader delegate); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); }### Answer:
@Test public void skip() throws IOException { cut.skip(999); verify(mockDelegate).skip(Mockito.anyLong()); } |
### Question:
EscapingReader extends Reader { @Override public boolean ready() throws IOException { return delegate.ready(); } EscapingReader(Reader delegate); EscapingReader(Object lock, Reader delegate); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); }### Answer:
@Test public void ready() throws IOException { cut.ready(); verify(mockDelegate).ready(); } |
### Question:
EscapingReader extends Reader { @Override public boolean markSupported() { return false; } EscapingReader(Reader delegate); EscapingReader(Object lock, Reader delegate); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); }### Answer:
@Test public void markSupported() throws IOException { assertFalse(cut.markSupported()); } |
### Question:
EscapingReader extends Reader { @Override public void mark(int readAheadLimit) throws IOException { throw new IOException("mark() not supported"); } EscapingReader(Reader delegate); EscapingReader(Object lock, Reader delegate); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); }### Answer:
@Test(expected = IOException.class) public void mark() throws IOException { cut.mark(0); } |
### Question:
EscapingReader extends Reader { @Override public void reset() throws IOException { throw new IOException("reset() not supported"); } EscapingReader(Reader delegate); EscapingReader(Object lock, Reader delegate); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); }### Answer:
@Test(expected = IOException.class) public void reset() throws IOException { cut.reset(); } |
### Question:
EscapingReader extends Reader { @Override public void close() throws IOException { delegate.close(); } EscapingReader(Reader delegate); EscapingReader(Object lock, Reader delegate); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); }### Answer:
@Test public void close() throws IOException { cut.close(); verify(mockDelegate).close(); } |
### Question:
PortfolioServiceImpl implements PortfolioService { @Override public void buy(int amount, JsonObject quote, Handler<AsyncResult<Portfolio>> resultHandler) { if (amount <= 0) { resultHandler.handle(Future.failedFuture("Cannot buy " + quote.getString("name") + " - the amount must be " + "greater than 0")); return; } if (quote.getInteger("shares") < amount) { resultHandler.handle(Future.failedFuture("Cannot buy " + amount + " - not enough " + "stocks on the market (" + quote.getInteger("shares") + ")")); return; } double price = amount * quote.getDouble("ask"); String name = quote.getString("name"); if (portfolio.getCash() >= price) { portfolio.setCash(portfolio.getCash() - price); int current = portfolio.getAmount(name); int newAmount = current + amount; portfolio.getShares().put(name, newAmount); sendActionOnTheEventBus("BUY", amount, quote, newAmount); resultHandler.handle(Future.succeededFuture(portfolio)); } else { resultHandler.handle(Future.failedFuture("Cannot buy " + amount + " of " + name + " - " + "not enough money, " + "need " + price + ", has " + portfolio.getCash())); } } PortfolioServiceImpl(Vertx vertx, ServiceDiscovery discovery, double initialCash); @Override void getPortfolio(Handler<AsyncResult<Portfolio>> resultHandler); @Override void evaluate(Handler<AsyncResult<Double>> resultHandler); @Override void buy(int amount, JsonObject quote, Handler<AsyncResult<Portfolio>> resultHandler); @Override void sell(int amount, JsonObject quote, Handler<AsyncResult<Portfolio>> resultHandler); }### Answer:
@Test public void testBuyStocks(TestContext tc) { Async async = tc.async(); service.buy(10, quote("A", 10, 20, 100), ar -> { tc.assertTrue(ar.succeeded()); Portfolio portfolio = ar.result(); tc.assertEquals(portfolio.getAmount("A"), 10); tc.assertEquals(portfolio.getAmount("B"), 0); tc.assertEquals(portfolio.getCash(), original.getCash() - 10 * 10); async.complete(); }); }
@Test public void testThatYouCannotBuyIfYouRunOutOfMoney(TestContext tc) { Async async = tc.async(); service.buy(10000, quote("A", 10, 20, 100000), ar -> { tc.assertTrue(ar.failed()); tc.assertTrue(ar.cause().getMessage().contains("not enough money")); async.complete(); }); }
@Test public void testThatYouCannotBuyIfThereIsNotEnoughShare(TestContext tc) { Async async = tc.async(); service.buy(100, quote("A", 10, 20, 10), ar -> { tc.assertTrue(ar.failed()); tc.assertTrue(ar.cause().getMessage().contains("not enough stocks")); async.complete(); }); }
@Test public void testYouCannotBuyANegativeAmount(TestContext tc) { Async async = tc.async(); service.buy(-1, quote("A", 10, 20, 100), ar -> { tc.assertTrue(ar.failed()); async.complete(); }); } |
### Question:
PortfolioServiceImpl implements PortfolioService { @Override public void sell(int amount, JsonObject quote, Handler<AsyncResult<Portfolio>> resultHandler) { if (amount <= 0) { resultHandler.handle(Future.failedFuture("Cannot sell " + quote.getString("name") + " - the amount must be " + "greater than 0")); return; } double price = amount * quote.getDouble("bid"); String name = quote.getString("name"); int current = portfolio.getAmount(name); if (current >= amount) { int newAmount = current - amount; if (newAmount == 0) { portfolio.getShares().remove(name); } else { portfolio.getShares().put(name, newAmount); } portfolio.setCash(portfolio.getCash() + price); sendActionOnTheEventBus("SELL", amount, quote, newAmount); resultHandler.handle(Future.succeededFuture(portfolio)); } else { resultHandler.handle(Future.failedFuture("Cannot sell " + amount + " of " + name + " - " + "not enough stocks " + "in portfolio")); } } PortfolioServiceImpl(Vertx vertx, ServiceDiscovery discovery, double initialCash); @Override void getPortfolio(Handler<AsyncResult<Portfolio>> resultHandler); @Override void evaluate(Handler<AsyncResult<Double>> resultHandler); @Override void buy(int amount, JsonObject quote, Handler<AsyncResult<Portfolio>> resultHandler); @Override void sell(int amount, JsonObject quote, Handler<AsyncResult<Portfolio>> resultHandler); }### Answer:
@Test public void testYouCannotSellANegativeAmount(TestContext tc) { Async async = tc.async(); service.sell(-1, quote("A", 10, 20, 100), ar -> { tc.assertTrue(ar.failed()); async.complete(); }); } |
### Question:
BCCryptoHelper implements ICryptoHelper { @Nonnull public KeyStore createNewKeyStore (@Nonnull final IKeyStoreType aKeyStoreType) throws GeneralSecurityException { try { return aKeyStoreType.getKeyStore (m_sSecurityProviderName); } catch (final Exception ex) { return aKeyStoreType.getKeyStore (); } } BCCryptoHelper(); @Nonnull @Nonempty String getSecurityProviderName(); @Nonnull BCCryptoHelper setSecurityProviderName(@Nonnull @Nonempty final String sSecurityProviderName); @Nonnull KeyStore createNewKeyStore(@Nonnull final IKeyStoreType aKeyStoreType); @Nonnull KeyStore loadKeyStore(@Nonnull final IKeyStoreType aKeyStoreType,
@Nullable @WillNotClose final InputStream aIS,
@Nonnull final char [] aPassword); boolean isEncrypted(@Nonnull final MimeBodyPart aPart); boolean isSigned(@Nonnull final MimeBodyPart aPart); boolean isCompressed(@Nonnull final String sContentType); @Nonnull MIC calculateMIC(@Nonnull final MimeBodyPart aPart,
@Nonnull final ECryptoAlgorithmSign eDigestAlgorithm,
final boolean bIncludeHeaders); @Nonnull MimeBodyPart decrypt(@Nonnull final MimeBodyPart aPart,
@Nonnull final X509Certificate aX509Cert,
@Nonnull final PrivateKey aPrivateKey,
final boolean bForceDecrypt,
@Nonnull final AS2ResourceHelper aResHelper); @Nonnull MimeBodyPart encrypt(@Nonnull final MimeBodyPart aPart,
@Nonnull final X509Certificate aX509Cert,
@Nonnull final ECryptoAlgorithmCrypt eAlgorithm,
@Nonnull final EContentTransferEncoding eCTE); @Nonnull MimeBodyPart sign(@Nonnull final MimeBodyPart aPart,
@Nonnull final X509Certificate aX509Cert,
@Nonnull final PrivateKey aPrivateKey,
@Nonnull final ECryptoAlgorithmSign eAlgorithm,
final boolean bIncludeCertificateInSignedContent,
final boolean bUseOldRFC3851MicAlgs,
@Nonnull final EContentTransferEncoding eCTE); @Nonnull MimeBodyPart verify(@Nonnull final MimeBodyPart aPart,
@Nullable final X509Certificate aX509Cert,
final boolean bUseCertificateInBodyPart,
final boolean bForceVerify,
@Nullable final Consumer <X509Certificate> aEffectiveCertificateConsumer,
@Nonnull final AS2ResourceHelper aResHelper); }### Answer:
@Test public void testCreateKeyStores () throws GeneralSecurityException { final BCCryptoHelper x = new BCCryptoHelper (); for (final EKeyStoreType e : EKeyStoreType.values ()) { assertNotNull (x.createNewKeyStore (e)); } } |
### Question:
MIC implements Serializable { @Nullable public static MIC parse (@Nullable final String sMIC) { if (StringHelper.hasNoText (sMIC)) return null; final StringTokenizer st = new StringTokenizer (sMIC, ", \t\r\n"); final String sMICBytes = st.nextToken (); final byte [] aMICBytes = Base64.safeDecode (sMICBytes); if (aMICBytes == null) throw new IllegalArgumentException ("Failed to base64 decode '" + sMICBytes + "'"); if (!st.hasMoreTokens ()) throw new IllegalArgumentException ("Separator after Base64 bytes is missing"); final String sAlgorithm = st.nextToken (); final ECryptoAlgorithmSign eDigestAlgorithm = ECryptoAlgorithmSign.getFromIDOrNull (sAlgorithm); if (eDigestAlgorithm == null) throw new IllegalArgumentException ("Failed to parse digest algorithm '" + sAlgorithm + "'"); return new MIC (aMICBytes, eDigestAlgorithm); } MIC(@Nonnull final byte [] aMICBytes, @Nonnull final ECryptoAlgorithmSign eDigestAlgorithm); @Nonnull byte [] micBytes(); @Nonnull ECryptoAlgorithmSign getDigestAlgorithm(); @Nonnull @Nonempty String getAsAS2String(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); @Nullable static MIC parse(@Nullable final String sMIC); }### Answer:
@Test public void testParseEmpty () { assertNull (MIC.parse (null)); assertNull (MIC.parse ("")); }
@Test (expected = IllegalArgumentException.class) public void testParseInvalidNoSep () { MIC.parse ("VGVzdA=="); }
@Test (expected = IllegalArgumentException.class) public void testParseInvalidNoAlg () { MIC.parse ("VGVzdA==, "); }
@Test (expected = IllegalArgumentException.class) public void testParseInvalidInvalidAlg () { MIC.parse ("VGVzdA==, blub"); } |
### Question:
HTTPHelper { public static int readChunkLen (@Nonnull @WillNotClose final InputStream aIS) throws IOException { int nRes = 0; boolean bHeadersStarted = false; for (;;) { int ch = aIS.read (); if (ch < 0) throw new EOFException (); if (ch == '\n') break; if (ch >= 'a' && ch <= 'f') ch -= ('a' - 10); else if (ch >= 'A' && ch <= 'F') ch -= ('A' - 10); else if (ch >= '0' && ch <= '9') ch -= '0'; else if (ch == ';') bHeadersStarted = true; else continue; if (!bHeadersStarted) nRes = (nRes * 16) + ch; } return nRes; } private HTTPHelper(); @Nonnull @ReturnsMutableCopy static ICommonsList <String> getAllHTTPHeaderLines(@Nonnull final InternetHeaders aHeaders); @Nullable static IHTTPIncomingDumper getHTTPIncomingDumper(); @Nonnull static ISupplier <? extends IHTTPIncomingDumper> getHTTPIncomingDumperFactory(); static void setHTTPIncomingDumperFactory(@Nonnull final ISupplier <? extends IHTTPIncomingDumper> aHttpDumperFactory); @Nonnull static DataSource readHttpRequest(@Nonnull final IAS2InputStreamProvider aISP,
@Nonnull final IAS2HttpResponseHandler aResponseHandler,
@Nonnull final IMessage aMsg,
@Nullable final IHTTPIncomingDumper aIncomingDumper); static void sendSimpleHTTPResponse(@Nonnull final IAS2HttpResponseHandler aResponseHandler,
@Nonnegative final int nResponseCode); static int readChunkLen(@Nonnull @WillNotClose final InputStream aIS); static void readTillNexLine(@Nonnull @WillNotClose final InputStream aIS); static final String MA_HTTP_REQ_TYPE; static final String MA_HTTP_REQ_URL; static final String MA_HTTP_REQ_VERSION; }### Answer:
@Test (expected = EOFException.class) public void testReadChunkLenEOS () throws Exception { final InputStream noNewLine = new StringInputStream ("1", StandardCharsets.UTF_8); HTTPHelper.readChunkLen (noNewLine); fail ("An EOFException should have been thrown"); }
@Test public void testReadChunkLenWithHeader () throws Exception { final NonBlockingByteArrayInputStream noNewLine = new NonBlockingByteArrayInputStream ("1A;name=value\r\n".getBytes (StandardCharsets.UTF_8)); final int res = HTTPHelper.readChunkLen (noNewLine); assertEquals ("Chunk size with header", 26, res); }
@Test public void testReadChunkLenNoHeader () throws Exception { final NonBlockingByteArrayInputStream noNewLine = new NonBlockingByteArrayInputStream ("1f\n".getBytes (StandardCharsets.UTF_8)); final int res = HTTPHelper.readChunkLen (noNewLine); assertEquals ("Chunk size with header", 31, res); }
@Test public void testReadChunkLenEmpty () throws Exception { final NonBlockingByteArrayInputStream noNewLine = new NonBlockingByteArrayInputStream ("\n".getBytes (StandardCharsets.UTF_8)); final int res = HTTPHelper.readChunkLen (noNewLine); assertEquals ("Chunk size with header", 0, res); } |
### Question:
TempSharedFileInputStream extends SharedFileInputStream { @Nonnull public static TempSharedFileInputStream getTempSharedFileInputStream (@Nonnull @WillClose final InputStream aIS, @Nonnull final String sName) throws IOException { final File aDest = storeContentToTempFile (aIS, sName); return new TempSharedFileInputStream (aDest); } private TempSharedFileInputStream(@Nonnull final File aFile); @Override void close(); void closeAll(); @Nonnull static TempSharedFileInputStream getTempSharedFileInputStream(@Nonnull @WillClose final InputStream aIS,
@Nonnull final String sName); }### Answer:
@Test public void testGetTempSharedFileInputStream () throws Exception { final String inData = "123456"; try (final InputStream is = new NonBlockingByteArrayInputStream (inData.getBytes ()); final SharedFileInputStream sis = TempSharedFileInputStream.getTempSharedFileInputStream (is, "myName"); final NonBlockingByteArrayOutputStream baos = new NonBlockingByteArrayOutputStream ()) { StreamHelper.copyInputStreamToOutputStream (sis, baos); final String res = baos.getAsString (StandardCharsets.ISO_8859_1); assertEquals ("read the data", inData, res); sis.close (); } } |
### Question:
TempSharedFileInputStream extends SharedFileInputStream { @Nonnull protected static File storeContentToTempFile (@Nonnull @WillClose final InputStream aIS, @Nonnull final String sName) throws IOException { final String sSuffix = FilenameHelper.getAsSecureValidASCIIFilename (StringHelper.hasText (sName) ? sName : "tmp"); final File aDestFile = File.createTempFile ("AS2TempSharedFileIS", sSuffix); try (final FileOutputStream aOS = new FileOutputStream (aDestFile)) { final MutableLong aCount = new MutableLong (0); StreamHelper.copyInputStreamToOutputStream (aIS, aOS, aCount); if (LOGGER.isInfoEnabled ()) { if (aCount.longValue () > 1024) LOGGER.info (aCount.longValue () + " bytes copied to " + aDestFile.getAbsolutePath ()); } } return aDestFile; } private TempSharedFileInputStream(@Nonnull final File aFile); @Override void close(); void closeAll(); @Nonnull static TempSharedFileInputStream getTempSharedFileInputStream(@Nonnull @WillClose final InputStream aIS,
@Nonnull final String sName); }### Answer:
@Test public void testStoreContentToTempFile () throws Exception { final String inData = "123456"; final String name = "xxy"; try (final InputStream is = new NonBlockingByteArrayInputStream (inData.getBytes (StandardCharsets.ISO_8859_1))) { final File file = TempSharedFileInputStream.storeContentToTempFile (is, name); assertTrue ("Temp file exists", file.exists ()); assertTrue ("Temp file name includes given name", file.getName ().indexOf (name) > 0); FileOperations.deleteFileIfExisting (file); } } |
### Question:
TempSharedFileInputStream extends SharedFileInputStream { @Override protected void finalize () throws Throwable { try { closeAll (); } catch (final Exception ex) { LOGGER.error ("Exception in finalize()", ex); } super.finalize (); } private TempSharedFileInputStream(@Nonnull final File aFile); @Override void close(); void closeAll(); @Nonnull static TempSharedFileInputStream getTempSharedFileInputStream(@Nonnull @WillClose final InputStream aIS,
@Nonnull final String sName); }### Answer:
@Test public void testFinalize () throws Exception { for (int i = 0; i < 10000; i++) { final String sSrcData = "123456"; try (final InputStream is = new NonBlockingByteArrayInputStream (sSrcData.getBytes (StandardCharsets.ISO_8859_1)); final TempSharedFileInputStream aSharedIS = TempSharedFileInputStream.getTempSharedFileInputStream (is, "myName")) { final int t = aSharedIS.read (); assertEquals (t, sSrcData.charAt (0)); aSharedIS.closeAll (); } } } |
### Question:
AS2IOHelper { @Nullable public static String getFilenameFromMessageID (@Nonnull final String sMessageID) { String s = StringHelper.removeAll (sMessageID, '<'); s = StringHelper.removeAll (s, '>'); return FilenameHelper.getAsSecureValidASCIIFilename (s); } private AS2IOHelper(); @Nonnull static FileOperationManager getFileOperationManager(); @Nonnull static File getDirectoryFile(@Nonnull final String sDirectory); @Nonnull @Nonempty static String getTransferRate(final long nBytes, @Nonnull final StopWatch aSW); @Nonnull static File getUniqueFile(@Nonnull final File aDir, @Nullable final String sFilename); static void handleError(@Nonnull final File aFile, @Nonnull final String sErrorDirectory); @Nonnull static File moveFile(@Nonnull final File aSrc,
@Nonnull final File aDestFile,
final boolean bOverwrite,
final boolean bRename); @Nullable static String getFilenameFromMessageID(@Nonnull final String sMessageID); @Nullable static String getSafeFileAndFolderName(@Nullable final String s); @Nonnull @ReturnsMutableCopy static byte [] getAllAsciiBytes(@Nonnull final String sString); @Nonnull static OutputStream getContentTransferEncodingAwareOutputStream(@Nonnull final OutputStream aOS,
@Nullable final String sEncoding); @Nonnull static InputStream getContentTransferEncodingAwareInputStream(@Nonnull final InputStream aIS,
@Nullable final String sEncoding); }### Answer:
@Test public void testGetFilenameFromMessageID () { assertNull (AS2IOHelper.getFilenameFromMessageID ("")); assertNull (AS2IOHelper.getFilenameFromMessageID ("<<<<>>>>")); assertEquals ("a", AS2IOHelper.getFilenameFromMessageID ("a")); assertEquals ("a", AS2IOHelper.getFilenameFromMessageID ("<a>")); assertEquals ("a", AS2IOHelper.getFilenameFromMessageID ("<<<<<a>>>>>")); assertEquals ("[email protected]", AS2IOHelper.getFilenameFromMessageID ("<<<<<[email protected]>>>>>")); } |
### Question:
AS2IOHelper { @Nullable public static String getSafeFileAndFolderName (@Nullable final String s) { if (StringHelper.hasNoText (s)) return s; final File aBase = new File (FilenameHelper.getPathUsingUnixSeparator (s)); final StringBuilder aSB = new StringBuilder (); File f = aBase; while (f != null) { final String sName = f.getName (); if (sName.length () == 0) { aSB.insert (0, FilenameHelper.getPathUsingUnixSeparator (f.getPath ())); } else { final String sSecuredName = FilenameHelper.getAsSecureValidASCIIFilename (sName); aSB.insert (0, StringHelper.getNotNull (sSecuredName, "") + FilenameHelper.UNIX_SEPARATOR); } f = f.getParentFile (); } return aSB.deleteCharAt (aSB.length () - 1).toString (); } private AS2IOHelper(); @Nonnull static FileOperationManager getFileOperationManager(); @Nonnull static File getDirectoryFile(@Nonnull final String sDirectory); @Nonnull @Nonempty static String getTransferRate(final long nBytes, @Nonnull final StopWatch aSW); @Nonnull static File getUniqueFile(@Nonnull final File aDir, @Nullable final String sFilename); static void handleError(@Nonnull final File aFile, @Nonnull final String sErrorDirectory); @Nonnull static File moveFile(@Nonnull final File aSrc,
@Nonnull final File aDestFile,
final boolean bOverwrite,
final boolean bRename); @Nullable static String getFilenameFromMessageID(@Nonnull final String sMessageID); @Nullable static String getSafeFileAndFolderName(@Nullable final String s); @Nonnull @ReturnsMutableCopy static byte [] getAllAsciiBytes(@Nonnull final String sString); @Nonnull static OutputStream getContentTransferEncodingAwareOutputStream(@Nonnull final OutputStream aOS,
@Nullable final String sEncoding); @Nonnull static InputStream getContentTransferEncodingAwareInputStream(@Nonnull final InputStream aIS,
@Nullable final String sEncoding); }### Answer:
@Test public void testgetSafeFileAndFolderName () { assertNull (AS2IOHelper.getSafeFileAndFolderName (null)); assertEquals ("", AS2IOHelper.getSafeFileAndFolderName ("")); assertEquals ("abc", AS2IOHelper.getSafeFileAndFolderName ("abc")); assertEquals ("abc/def", AS2IOHelper.getSafeFileAndFolderName ("abc/def")); assertEquals ("abc/def", AS2IOHelper.getSafeFileAndFolderName ("abc\\def")); assertEquals ("abc/def/blub", AS2IOHelper.getSafeFileAndFolderName ("abc/def\\blub")); assertEquals ("abc_/d_ef/g_hi", AS2IOHelper.getSafeFileAndFolderName ("abc</d|ef\\g*hi")); assertEquals ("/abc", AS2IOHelper.getSafeFileAndFolderName ("/abc")); assertEquals ("/abc", AS2IOHelper.getSafeFileAndFolderName ("\\abc")); assertEquals ("abc", AS2IOHelper.getSafeFileAndFolderName ("abc/")); assertEquals ("abc", AS2IOHelper.getSafeFileAndFolderName ("abc\\")); assertEquals ("/abc", AS2IOHelper.getSafeFileAndFolderName ("/abc/")); assertEquals ("/abc", AS2IOHelper.getSafeFileAndFolderName ("/abc\\")); assertEquals ("/abc", AS2IOHelper.getSafeFileAndFolderName ("\\abc/")); assertEquals ("/abc", AS2IOHelper.getSafeFileAndFolderName ("\\abc\\")); assertEquals ("z:/abc", AS2IOHelper.getSafeFileAndFolderName ("z:\\abc\\")); assertEquals ("z:/abc/test.txt", AS2IOHelper.getSafeFileAndFolderName ("z:\\abc/test.txt")); assertEquals ("z:/a_bc/tes_t.txt", AS2IOHelper.getSafeFileAndFolderName ("z:\\a*bc/tesät.txt")); assertEquals ("z:/com1", AS2IOHelper.getSafeFileAndFolderName ("z:\\com1")); assertEquals ("z:/_com2", AS2IOHelper.getSafeFileAndFolderName ("z:\\com2")); } |
### Question:
AS2HttpHelper { @Nullable public static ContentType parseContentType (@Nullable final String sContentType) { if (StringHelper.hasText (sContentType)) { final String sRealContentType = RFC2616Codec.isMaybeEncoded (sContentType) ? new RFC2616Codec ().getDecodedAsString (sContentType) : sContentType; try { return new ContentType (sRealContentType); } catch (final ParseException ex) { if (LOGGER.isDebugEnabled ()) LOGGER.debug ("Error parsing Content-Type '" + sContentType + "'", ex); } } return null; } private AS2HttpHelper(); @Nullable static ContentType parseContentType(@Nullable final String sContentType); @Nullable static String getCleanContentType(@Nullable final String sContentType); @Nonnull static InternetHeaders getAsInternetHeaders(@Nonnull final HttpHeaderMap aHeaders); }### Answer:
@Test public void testParseContentType () { assertNull (AS2HttpHelper.parseContentType (null)); assertNull (AS2HttpHelper.parseContentType ("")); assertNull (AS2HttpHelper.parseContentType (" ")); assertNull (AS2HttpHelper.parseContentType ("abc")); assertNull (AS2HttpHelper.parseContentType ("abc/")); assertNotNull (AS2HttpHelper.parseContentType ("abc/def")); assertNotNull (AS2HttpHelper.parseContentType ("abc/def; a=b")); assertNotNull (AS2HttpHelper.parseContentType (" abc/def ; a = b ")); assertNotNull (AS2HttpHelper.parseContentType ("abc/def; a=b; c=d")); assertNotNull (AS2HttpHelper.parseContentType (" abc/def ; a = b ; c = d ")); } |
### Question:
AS2HttpHelper { @Nullable public static String getCleanContentType (@Nullable final String sContentType) { final ContentType aCT = parseContentType (sContentType); return aCT != null ? aCT.toString () : null; } private AS2HttpHelper(); @Nullable static ContentType parseContentType(@Nullable final String sContentType); @Nullable static String getCleanContentType(@Nullable final String sContentType); @Nonnull static InternetHeaders getAsInternetHeaders(@Nonnull final HttpHeaderMap aHeaders); }### Answer:
@Test public void testGetCleanContentType () { assertNull (AS2HttpHelper.getCleanContentType (null)); assertNull (AS2HttpHelper.getCleanContentType ("")); assertNull (AS2HttpHelper.getCleanContentType (" ")); assertNull (AS2HttpHelper.getCleanContentType ("abc")); assertNull (AS2HttpHelper.getCleanContentType ("abc/")); assertEquals ("abc/def", AS2HttpHelper.getCleanContentType ("abc/def")); assertEquals ("abc/def; a=b", AS2HttpHelper.getCleanContentType ("abc/def; a=b")); assertEquals ("abc/def; a=b", AS2HttpHelper.getCleanContentType (" abc/def ; a = b ")); assertEquals ("abc/def; a=b; c=d", AS2HttpHelper.getCleanContentType ("abc/def; a=b; c=d")); assertEquals ("abc/def; a=b; c=d", AS2HttpHelper.getCleanContentType (" abc/def ; a = b ; c = d ")); } |
### Question:
MongoDBPartnershipFactory extends AbstractDynamicComponent implements IPartnershipFactory { @Override public EChange addPartnership (final Partnership aPartnership) throws AS2Exception { m_aPartnerships.insertOne (_toDocument (aPartnership)); return EChange.CHANGED; } MongoDBPartnershipFactory(final MongoCollection <Document> aPartnerships, final Logger aLogger); @Override EChange addPartnership(final Partnership aPartnership); @Override EChange removePartnership(final Partnership aPartnership); @Override void updatePartnership(final IMessage aMsg, final boolean bOverwrite); @Override void updatePartnership(final IMessageMDN aMdn, final boolean bOverwrite); @Override Partnership getPartnership(final Partnership aPartnership); @Override Partnership getPartnershipByName(final String sName); @Override ICommonsSet <String> getAllPartnershipNames(); @Override ICommonsList <Partnership> getAllPartnerships(); }### Answer:
@Test public void testAddPartnership () throws AS2Exception { final Partnership partnership = new Partnership ("Test partnership"); assertTrue (mongoDBPartnershipFactory.addPartnership (partnership).isChanged ()); assertEquals (1, collection.countDocuments ()); assertNotNull (mongoDBPartnershipFactory.getPartnershipByName ("Test partnership")); } |
### Question:
DiscreteAnneal { public String getStatus() { final StringBuilder result = new StringBuilder(); result.append("k="); result.append(this.k); result.append(",kMax="); result.append(this.kMax); result.append(",t="); result.append(this.currentTemperature); result.append(",prob="); result.append(this.lastProbability); return result.toString(); } DiscreteAnneal(final int theKMax, final double theStartingTemperature, final double theEndingTemperature); double coolingSchedule(); void iteration(); abstract void backupState(); abstract void restoreState(); abstract void foundNewBest(); abstract void moveToNeighbor(); abstract double evaluate(); boolean done(); double getBestScore(); double calcProbability(final double ecurrent, final double enew, final double t); int getK(); int getCycles(); void setCycles(final int cycles); String getStatus(); }### Answer:
@Test public void testStatus() { final DiscreteAnnealSubclass anneal = new DiscreteAnnealSubclass(1000, 4000, 1); assertEquals("k=0,kMax=1000,t=0.0,prob=0.0", anneal.getStatus()); } |
### Question:
KMeans { public void initForgy(final List<BasicData> theObservations) { final int dimensions = findDimensions(theObservations); this.clusters.clear(); final Set<Integer> usedObservations = new HashSet<Integer>(); for (int i = 0; i < this.k; i++) { final Cluster cluster = new Cluster(dimensions); this.clusters.add(cluster); int observationIndex = -1; while (observationIndex == -1) { observationIndex = this.randomGeneration.nextInt(theObservations.size()); if (usedObservations.contains(observationIndex)) { observationIndex = -1; } } final double[] observation = theObservations.get(observationIndex).getInput(); System.arraycopy(observation, 0, cluster.getCenter(), 0, dimensions); usedObservations.add(observationIndex); } for (final BasicData observation : theObservations) { final Cluster cluster = findNearestCluster(observation.getInput()); cluster.getObservations().add(observation); } updateStep(); } KMeans(final int theK); void initRandom(final List<BasicData> theObservations); void initForgy(final List<BasicData> theObservations); Cluster findNearestCluster(final double[] observation); boolean iteration(); int iteration(final int maxIterations); GenerateRandom getRandomGeneration(); void setRandomGeneration(final GenerateRandom randomGeneration); CalculateDistance getDistanceMetric(); void setDistanceMetric(final CalculateDistance distanceMetric); int getK(); List<Cluster> getClusters(); }### Answer:
@Test(expected = AIFHError.class) public void testNoObservations() { final List<BasicData> list = new ArrayList<BasicData>(); final KMeans kmeans = new KMeans(3); kmeans.initForgy(list); }
@Test(expected = AIFHError.class) public void testNoDimension() { final List<BasicData> list = new ArrayList<BasicData>(); list.add(new BasicData(0)); final KMeans kmeans = new KMeans(3); kmeans.initForgy(list); } |
### Question:
BasicData { public String toString() { final StringBuilder result = new StringBuilder(); result.append("[BasicData: input:"); result.append(Arrays.toString(this.input)); result.append(", ideal:"); result.append(Arrays.toString(this.ideal)); result.append(", label:"); result.append(this.label); result.append("]"); return result.toString(); } BasicData(final int theInputDimensions); BasicData(final int theInputDimensions, final int theIdealDimensions); BasicData(final int theInputDimensions, final int theIdealDimensions, final String theLabel); BasicData(final double[] theInputData, final double[] theIdealData, final String theLabel); BasicData(final double[] theInputData, final String theLabel); BasicData(final double[] theInputData); double[] getInput(); double[] getIdeal(); String getLabel(); void setLabel(final String label); String toString(); static List<BasicData> convertArrays(final double[][] inputData, final double[][] idealData); }### Answer:
@Test public void testToString() { final BasicData data = new BasicData(2); assertEquals("[BasicData: input:[0.0, 0.0], ideal:[], label:null]", data.toString()); } |
### Question:
VectorUtil { public static int maxIndex(final double[] a) { int result = -1; double max = Double.NEGATIVE_INFINITY; for (int i = 0; i < a.length; i++) { if (a[i] > max) { max = a[i]; result = i; } } return result; } private VectorUtil(); static int maxIndex(final double[] a); }### Answer:
@Test public void testMaxIndex() { final double[] a = {2, 4, 10, 8}; assertEquals(2, VectorUtil.maxIndex(a), AIFH.DEFAULT_PRECISION); } |
### Question:
LogLinkFunction implements Fn { @Override public double evaluate(final double[] x) { if (x.length > 1) { throw new AIFHError("The logistic link function can only accept one parameter."); } return Math.log(x[0]); } @Override double evaluate(final double[] x); }### Answer:
@Test public void testEvaluate() { final LogLinkFunction fn = new LogLinkFunction(); final double[] x = {2}; final double y = fn.evaluate(x); assertEquals(0.6931471805599453, y, AIFH.DEFAULT_PRECISION); }
@Test(expected = AIFHError.class) public void testException() { final LogLinkFunction fn = new LogLinkFunction(); final double[] x = {1, 2}; fn.evaluate(x); } |
### Question:
IdentityLinkFunction implements Fn { @Override public double evaluate(final double[] x) { if (x.length > 1) { throw new AIFHError("The linear link function can only accept one parameter."); } return x[0]; } @Override double evaluate(final double[] x); }### Answer:
@Test public void testEvaluate() { final IdentityLinkFunction fn = new IdentityLinkFunction(); final double[] x = {2}; final double y = fn.evaluate(x); assertEquals(2, y, AIFH.DEFAULT_PRECISION); }
@Test(expected = AIFHError.class) public void testException() { final IdentityLinkFunction fn = new IdentityLinkFunction(); final double[] x = {1, 2}; fn.evaluate(x); } |
### Question:
InverseLinkFunction implements Fn { @Override public double evaluate(final double[] x) { if (x.length > 1) { throw new AIFHError("The inverse link function can only accept one parameter."); } return -Math.pow(x[0], -1); } @Override double evaluate(final double[] x); }### Answer:
@Test public void testEvaluate() { final InverseLinkFunction fn = new InverseLinkFunction(); final double[] x = {2}; final double y = fn.evaluate(x); assertEquals(-0.5, y, AIFH.DEFAULT_PRECISION); }
@Test(expected = AIFHError.class) public void testException() { final InverseLinkFunction fn = new InverseLinkFunction(); final double[] x = {1, 2}; fn.evaluate(x); } |
### Question:
DiscreteAnneal { public double coolingSchedule() { final double ex = (double) k / (double) kMax; return this.startingTemperature * Math.pow(this.endingTemperature / this.startingTemperature, ex); } DiscreteAnneal(final int theKMax, final double theStartingTemperature, final double theEndingTemperature); double coolingSchedule(); void iteration(); abstract void backupState(); abstract void restoreState(); abstract void foundNewBest(); abstract void moveToNeighbor(); abstract double evaluate(); boolean done(); double getBestScore(); double calcProbability(final double ecurrent, final double enew, final double t); int getK(); int getCycles(); void setCycles(final int cycles); String getStatus(); }### Answer:
@Test public void testCoolingSchedule() { final DiscreteAnnealSubclass anneal = new DiscreteAnnealSubclass(1000, 400, 1); assertEquals(400, anneal.coolingSchedule(), AIFH.DEFAULT_PRECISION); anneal.iteration(); assertEquals(397.61057939346017, anneal.coolingSchedule(), AIFH.DEFAULT_PRECISION); } |
### Question:
LogitLinkFunction implements Fn { @Override public double evaluate(final double[] x) { if (x.length > 1) { throw new AIFHError("The logistic link function can only accept one parameter."); } return 1.0 / (1.0 + Math.exp(-x[0])); } @Override double evaluate(final double[] x); }### Answer:
@Test public void testEvaluate() { final LogitLinkFunction fn = new LogitLinkFunction(); final double[] x = {2}; final double y = fn.evaluate(x); assertEquals(0.8807970779778823, y, AIFH.DEFAULT_PRECISION); }
@Test(expected = AIFHError.class) public void testException() { final LogitLinkFunction fn = new LogitLinkFunction(); final double[] x = {1, 2}; fn.evaluate(x); } |
### Question:
InverseSquaredLinkFunction implements Fn { @Override public double evaluate(final double[] x) { if (x.length > 1) { throw new AIFHError("The inverse squared link function can only accept one parameter."); } return -Math.pow(x[0], -2); } @Override double evaluate(final double[] x); }### Answer:
@Test public void testEvaluate() { final InverseSquaredLinkFunction fn = new InverseSquaredLinkFunction(); final double[] x = {2}; final double y = fn.evaluate(x); assertEquals(-0.25, y, AIFH.DEFAULT_PRECISION); }
@Test(expected = AIFHError.class) public void testException() { final InverseSquaredLinkFunction fn = new InverseSquaredLinkFunction(); final double[] x = {1, 2}; fn.evaluate(x); } |
### Question:
GaussianFunction extends AbstractRBF { @Override public double evaluate(final double[] x) { double value = 0; final double width = getWidth(); for (int i = 0; i < getDimensions(); i++) { final double center = this.getCenter(i); value += Math.pow(x[i] - center, 2) / (2.0 * width * width); } return Math.exp(-value); } GaussianFunction(final int theDimensions, final double[] theParams, final int theIndex); @Override double evaluate(final double[] x); }### Answer:
@Test public void testEvaluate() { final double[] params = {5, 0, 0, 0}; final GaussianFunction funct = new GaussianFunction(3, params, 0); final double[] x = {-1, 0, 1}; final double y = funct.evaluate(x); assertEquals(0.9607894391523232, y, AIFH.DEFAULT_PRECISION); }
@Test public void testToString() { final double[] params = {5, 0, 0, 0}; final GaussianFunction funct = new GaussianFunction(3, params, 0); final double[] x = {-1, 0, 1}; funct.evaluate(x); assertEquals("[GaussianFunction:width=5.00,center=0.00,0.00,0.00]", funct.toString()); } |
### Question:
MultiquadricFunction extends AbstractRBF { @Override public double evaluate(final double[] x) { double value = 0; final double width = getWidth(); for (int i = 0; i < getDimensions(); i++) { final double center = getCenter(i); value += Math.pow(x[i] - center, 2) + (width * width); } return Math.sqrt(value); } MultiquadricFunction(final int theDimensions, final double[] theParams, final int theIndex); @Override double evaluate(final double[] x); }### Answer:
@Test public void testEvaluate() { final double[] params = {5, 0, 0, 0}; final MultiquadricFunction funct = new MultiquadricFunction(3, params, 0); final double[] x = {-1, 0, 1}; final double y = funct.evaluate(x); assertEquals(8.774964387392123, y, AIFH.DEFAULT_PRECISION); }
@Test public void testToString() { final double[] params = {5, 0, 0, 0}; final MultiquadricFunction funct = new MultiquadricFunction(3, params, 0); final double[] x = {-1, 0, 1}; funct.evaluate(x); assertEquals("[MultiquadricFunction:width=5.00,center=0.00,0.00,0.00]", funct.toString()); } |
### Question:
InverseMultiquadricFunction extends AbstractRBF { @Override public double evaluate(final double[] x) { double value = 0; final double width = getWidth(); for (int i = 0; i < getDimensions(); i++) { final double center = getCenter(i); value += Math.pow(x[i] - center, 2) + (width * width); } return 1 / Math.sqrt(value); } InverseMultiquadricFunction(final int theDimensions, final double[] theParams, final int theIndex); @Override double evaluate(final double[] x); }### Answer:
@Test public void testEvaluate() { final double[] params = {5, 0, 0, 0}; final InverseMultiquadricFunction funct = new InverseMultiquadricFunction(3, params, 0); final double[] x = {-1, 0, 1}; final double y = funct.evaluate(x); assertEquals(0.11396057645963795, y, AIFH.DEFAULT_PRECISION); }
@Test public void testToString() { final double[] params = {5, 0, 0, 0}; final InverseMultiquadricFunction funct = new InverseMultiquadricFunction(3, params, 0); final double[] x = {-1, 0, 1}; funct.evaluate(x); assertEquals("[InverseMultiquadricFunction:width=5.00,center=0.00,0.00,0.00]", funct.toString()); } |
### Question:
ScoreClassificationData implements ScoreFunction { @Override public double calculateScore(final MachineLearningAlgorithm algo) { int incorrectCount = 0; int totalCount = 0; final ClassificationAlgorithm ralgo = (ClassificationAlgorithm) algo; for (final BasicData aTrainingData : this.trainingData) { totalCount++; final int output = ralgo.computeClassification(aTrainingData.getInput()); if (output != (int) aTrainingData.getIdeal()[0]) { incorrectCount++; } } return (double) incorrectCount / (double) totalCount; } ScoreClassificationData(final List<BasicData> theTrainingData); @Override double calculateScore(final MachineLearningAlgorithm algo); }### Answer:
@Test public void testClassification() { final double[] ACTUAL = {0.0, 1.0, 0.0, 0.0}; final List<BasicData> training = BasicData.convertArrays(TEST_INPUT, TEST_IDEAL); final ScoreClassificationData score = new ScoreClassificationData(training); final SimpleAlgo simple = new SimpleAlgo(ACTUAL); final double s = score.calculateScore(simple); assertEquals(0.25, s, AIFH.DEFAULT_PRECISION); } |
### Question:
MexicanHatFunction extends AbstractRBF { @Override public double evaluate(final double[] x) { double norm = 0; for (int i = 0; i < getDimensions(); i++) { final double center = this.getCenter(i); norm += Math.pow(x[i] - center, 2); } return (1 - norm) * Math.exp(-norm / 2); } MexicanHatFunction(final int theDimensions, final double[] theParams, final int theIndex); @Override double evaluate(final double[] x); }### Answer:
@Test public void testEvaluate() { final double[] params = {5, 0, 0, 0}; final MexicanHatFunction funct = new MexicanHatFunction(3, params, 0); final double[] x = {-1, 0, 1}; final double y = funct.evaluate(x); assertEquals(-0.36787944117144233, y, AIFH.DEFAULT_PRECISION); }
@Test public void testToString() { final double[] params = {5, 0, 0, 0}; final MexicanHatFunction funct = new MexicanHatFunction(3, params, 0); final double[] x = {-1, 0, 1}; funct.evaluate(x); assertEquals("[MexicanHatFunction:width=5.00,center=0.00,0.00,0.00]", funct.toString()); } |
### Question:
DataSet { @Override public boolean equals(final Object other) { if (!(other instanceof DataSet)) { return false; } final DataSet otherSet = (DataSet) other; if (getHeaderCount() != otherSet.getHeaderCount()) { return false; } if (size() != otherSet.size()) { return false; } for (int i = 0; i < getHeaderCount(); i++) { if (!this.headers[i].equals(otherSet.getHeaders()[i])) { return false; } } for (int i = 0; i < size(); i++) { final Object[] row1 = this.data.get(i); final Object[] row2 = ((DataSet) other).getData().get(i); for (int j = 0; j < getHeaderCount(); j++) { if (!row1[j].equals(row2[j])) { return false; } } } return true; } DataSet(final String[] theHeaders); static DataSet load(final File filename); static DataSet load(final InputStream is); static void save(final File filename, final DataSet ds); static void save(final OutputStream os, final DataSet ds); int getHeaderCount(); String[] getHeaders(); void add(final Object[] row); List<Object[]> getData(); double getMax(final int column); double getMin(final int column); void normalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeRange(final int column, final double normalizedLow, final double normalizedHigh); void deNormalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeReciprocal(final int column); void deNormalizeReciprocal(final int column); Map<String, Integer> enumerateClasses(final int column); Map<String, Integer> encodeNumeric(final int column); Map<String, Integer> encodeOneOfN(final int column); Map<String, Integer> encodeOneOfN(final int column, final double offValue, final double onValue); Map<String, Integer> encodeEquilateral(final int column); Map<String, Integer> encodeEquilateral(final int column, final double offValue, final double onValue); int size(); void appendColumns(final int count); void insertColumns(final int column, final int columnCount); @Override boolean equals(final Object other); List<BasicData> extractUnsupervisedLabeled(final int labelIndex); List<BasicData> extractSupervised(final int inputBegin, final int inputCount, final int idealBegin, final int idealCount); void deleteUnknowns(); void deleteColumn(final int col); void replaceColumn(final int columnIndex, final double searchFor, final double replaceWith, final double others); }### Answer:
@Test public void testEqual() { final DataSet ds1 = generateTestData(); final DataSet ds2 = generateTestData(); assertTrue(ds1.equals(ds2)); }
@Test public void testNotEqualOtherObject() { final DataSet ds1 = generateTestData(); assertFalse(ds1.equals("")); } |
### Question:
DataSet { public double getMin(final int column) { double result = Double.POSITIVE_INFINITY; for (final Object[] obj : this.data) { result = Math.min(result, convertNumeric(obj, column)); } return result; } DataSet(final String[] theHeaders); static DataSet load(final File filename); static DataSet load(final InputStream is); static void save(final File filename, final DataSet ds); static void save(final OutputStream os, final DataSet ds); int getHeaderCount(); String[] getHeaders(); void add(final Object[] row); List<Object[]> getData(); double getMax(final int column); double getMin(final int column); void normalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeRange(final int column, final double normalizedLow, final double normalizedHigh); void deNormalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeReciprocal(final int column); void deNormalizeReciprocal(final int column); Map<String, Integer> enumerateClasses(final int column); Map<String, Integer> encodeNumeric(final int column); Map<String, Integer> encodeOneOfN(final int column); Map<String, Integer> encodeOneOfN(final int column, final double offValue, final double onValue); Map<String, Integer> encodeEquilateral(final int column); Map<String, Integer> encodeEquilateral(final int column, final double offValue, final double onValue); int size(); void appendColumns(final int count); void insertColumns(final int column, final int columnCount); @Override boolean equals(final Object other); List<BasicData> extractUnsupervisedLabeled(final int labelIndex); List<BasicData> extractSupervised(final int inputBegin, final int inputCount, final int idealBegin, final int idealCount); void deleteUnknowns(); void deleteColumn(final int col); void replaceColumn(final int columnIndex, final double searchFor, final double replaceWith, final double others); }### Answer:
@Test public void testMin() { final DataSet ds1 = generateTestData(); assertEquals(1.0, ds1.getMin(1), AIFH.DEFAULT_PRECISION); assertEquals(1.0, ds1.getMin(1), AIFH.DEFAULT_PRECISION); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.