Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: AbortPolicyWithReport extends ThreadPoolExecutor.AbortPolicy { @Override public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { String msg = String.format("Thread pool is EXHAUSTED!" + " Thread Name: %s, Pool Size: %d (active: %d, core: %d, max: %d, largest: %d), Task: %d (completed: %d)," + " Executor status:(isShutdown:%s, isTerminated:%s, isTerminating:%s), in %s: threadName, e.getPoolSize(), e.getActiveCount(), e.getCorePoolSize(), e.getMaximumPoolSize(), e.getLargestPoolSize(), e.getTaskCount(), e.getCompletedTaskCount(), e.isShutdown(), e.isTerminated(), e.isTerminating(), url.getProtocol(), url.getIp(), url.getPort()); logger.warn(msg); dumpJStack(); throw new RejectedExecutionException(msg); } AbortPolicyWithReport(String threadName, URL url); @Override void rejectedExecution(Runnable r, ThreadPoolExecutor e); }### Answer: @Test public void jStackDumpTest() throws InterruptedException { URL url = URL.valueOf("dubbo: AbortPolicyWithReport abortPolicyWithReport = new AbortPolicyWithReport("Test", url); try { abortPolicyWithReport.rejectedExecution(new Runnable() { @Override public void run() { System.out.println("hello"); } }, (ThreadPoolExecutor) Executors.newFixedThreadPool(1)); } catch (RejectedExecutionException rj) { } Thread.sleep(1000); }
### Question: WebServiceProtocol extends AbstractProxyProtocol { public WebServiceProtocol() { super(Fault.class); bus.setExtension(new ServletDestinationFactory(), HttpDestinationFactory.class); } WebServiceProtocol(); void setHttpBinder(HttpBinder httpBinder); @Override int getDefaultPort(); static final int DEFAULT_PORT; }### Answer: @Test public void testWebserviceProtocol() throws Exception { DemoService service = new DemoServiceImpl(); protocol.export(proxy.getInvoker(service, DemoService.class, URL.valueOf("webservice: service = proxy.getProxy(protocol.refer(DemoService.class, URL.valueOf("webservice: assertEquals(service.create(1, "kk").getName(), "kk"); assertEquals(service.getSize(null), -1); assertEquals(service.getSize(new String[]{"", "", ""}), 3); Object object = service.invoke("webservice: System.out.println(object); assertEquals("webservice: StringBuffer buf = new StringBuffer(); for (int i = 0; i < 1024 * 32 + 32; i++) buf.append('A'); assertEquals(32800, service.stringLength(buf.toString())); }
### Question: DaggerLifecycleDelegate { public Object onRetainCustomNonConfigurationInstance() { return daggerComponent; } DaggerLifecycleDelegate(@NonNull DaggerComponentFactory<T> daggerComponentFactory); @SuppressWarnings("unchecked") void onCreate(AppCompatActivity activity); Object onRetainCustomNonConfigurationInstance(); T daggerComponent(); }### Answer: @Test public void onRetainCustomNonConfigurationInstance_THEN_return_dagger_component() throws Exception { assertThat(tested.onRetainCustomNonConfigurationInstance()).isEqualTo(tested.daggerComponent); }
### Question: DaggerLifecycleDelegate { public T daggerComponent() { return daggerComponent; } DaggerLifecycleDelegate(@NonNull DaggerComponentFactory<T> daggerComponentFactory); @SuppressWarnings("unchecked") void onCreate(AppCompatActivity activity); Object onRetainCustomNonConfigurationInstance(); T daggerComponent(); }### Answer: @Test public void daggerComponent_THEN_return_dagger_component() throws Exception { assertThat(tested.daggerComponent()).isEqualTo(tested.daggerComponent); }
### Question: CollectionsX { public static <T> List<T> concat(@NonNull List<T> list1, @NonNull List<T> list2) { final ArrayList<T> list = new ArrayList<>(list1.size() + list2.size()); if (!list1.isEmpty()) { list.addAll(list1); } if (!list2.isEmpty()) { list.addAll(list2); } return list; } private CollectionsX(); static List<T> concat(@NonNull List<T> list1, @NonNull List<T> list2); }### Answer: @Test public void should_return_concatenated_list() throws Exception { assertThat(CollectionsX.concat(Arrays.asList(1, 2, 3), Arrays.asList(4, 5, 6))) .isEqualTo(Arrays.asList(1, 2, 3, 4, 5, 6)); }
### Question: AppRouter { public Intent loginIntent(Context context) { return intentFactory.create(context, LoginActivity.class); } AppRouter(); @VisibleForTesting AppRouter(IntentFactory intentFactory); Intent loginIntent(Context context); }### Answer: @Test public void should_return_loginIntent() throws Exception { tested.loginIntent(mockedContext); verify(mockedIntentFactory).create(mockedContext, LoginActivity.class); }
### Question: EmailValidator { public boolean isValid(CharSequence email) { return email != null && EMAIL_ADDRESS.matcher(email).matches(); } boolean isValid(CharSequence email); Observable<Boolean> checkEmail(CharSequence email); }### Answer: @Test public void should_return_false_when_email_is_null() throws Exception { assertThat(tested.isValid(null)).isFalse(); } @Test public void should_return_false_when_email_is_invalid() throws Exception { assertThat(tested.isValid("abc")).isFalse(); } @Test public void should_return_true_when_email_is_valid() throws Exception { assertThat(tested.isValid("[email protected]")).isTrue(); }
### Question: PolicyConditionCacheConfig { @Bean public GroovyConditionCache conditionCache( @Value("${ENABLE_DECISION_CACHING:true}") final boolean decisionCachingEnabled) { if (decisionCachingEnabled) { LOGGER.info( "In-memory condition caching disabled for policy evaluation (superseded by decision caching)."); return new NonCachingGroovyConditionCache(); } LOGGER.info("In-memory condition caching enabled for policy evaluation."); return new InMemoryGroovyConditionCache(); } @Bean GroovyConditionCache conditionCache( @Value("${ENABLE_DECISION_CACHING:true}") final boolean decisionCachingEnabled); }### Answer: @Test public void testPolicyConditionCacheConfigDisabled() { assertThat(this.policyConditionCacheConfig.conditionCache(true), instanceOf(NonCachingGroovyConditionCache.class)); } @Test public void testPolicyConditionCacheConfigEnabled() { assertThat(this.policyConditionCacheConfig.conditionCache(false), instanceOf(InMemoryGroovyConditionCache.class)); }
### Question: GroovyConditionShell { public ConditionScript parse(final String script) throws ConditionParsingException { return parse(script, true); } GroovyConditionShell(final GroovyConditionCache conditionCache); ConditionScript parse(final String script); boolean execute(final String script, final Map<String, Object> boundVariables); }### Answer: @Test(dataProvider = "validScript") public void testParseValidScript(final String script, final Map<String, Object> boundVariables, final boolean expectedResult) throws ConditionParsingException { ConditionScript parsedScript = this.shell.parse(script); Assert.assertNotNull(parsedScript); } @Test(dataProvider = "illegalScript", expectedExceptions = IllegalArgumentException.class) public void testParseBlankScript(final String script) throws ConditionParsingException { this.shell.parse(script); } @Test(dataProvider = "blackListedScript", expectedExceptions = ConditionParsingException.class) public void testParseBlackListedScript(final String script) throws ConditionParsingException { this.shell.parse(script); }
### Question: GroovyConditionShell { public boolean execute(final String script, final Map<String, Object> boundVariables) throws ConditionParsingException { ConditionScript conditionScript = parse(script, false); try { return conditionScript.execute(boundVariables); } catch (ConditionAssertionFailedException e) { return false; } finally { removeLoadedClasses(); } } GroovyConditionShell(final GroovyConditionCache conditionCache); ConditionScript parse(final String script); boolean execute(final String script, final Map<String, Object> boundVariables); }### Answer: @Test(dataProvider = "validScript") public void testExecuteValidScript(final String script, final Map<String, Object> boundVariables, final boolean expectedResult) throws ConditionParsingException { Assert.assertEquals(this.shell.execute(script, boundVariables), expectedResult); } @Test(dataProvider = "illegalScript", expectedExceptions = IllegalArgumentException.class) public void testExecuteBlankScript(final String script) throws ConditionParsingException { this.shell.execute(script, emptyBindingMap); } @Test(dataProvider = "invalidScript", expectedExceptions = ClassCastException.class) public void testExecuteInvalidScript(final String script) throws ConditionParsingException { this.shell.execute(script, emptyBindingMap); } @Test(dataProvider = "blackListedScript", expectedExceptions = ConditionParsingException.class) public void testExecuteBlackListedScript(final String script) throws ConditionParsingException { this.shell.execute(script, emptyBindingMap); }
### Question: URL implements URLComponent, Validating, Comparable<URL> { public URL withProtocol(Protocol protocol) { if (protocol.equals(this.protocol)) { return this; } return new URL(userName, password, protocol, host, port, path, parameters, anchor); } URL(String userName, String password, Protocol protocol, Host host, Port port, Path path, Parameters query, Anchor anchor); URL withProtocol(Protocol protocol); static URLBuilder builder(); static URLBuilder builder(Protocol protocol); static URLBuilder builder(URL startWith); static URL parse(String url); URL getBaseURL(boolean retainPort); Anchor getAnchor(); Host getHost(); Path getPath(); Port getPort(); Protocol getProtocol(); Parameters getParameters(); URLComponent getUserName(); URLComponent getPassword(); boolean isKnownProtocol(); boolean isProbableFileReference(); boolean isSameDomain(String domain); HostAndPort getHostAndPort(); void appendTo(StringBuilder sb); String getPathAndQuery(); boolean isSecure(); URLComponent[] components(); URLComponent[] allComponents(); URLComponent getInvalidComponent(); @Override boolean isValid(); String getComponentName(); @Override String toString(); String toUnescapedForm(); URL stripAnchor(); URL stripQuery(); URL toSimpleURL(); URI toURI(); URL withParameter(String name, String value); boolean simpleEquals(URL other); URL getParentURL(); static URL fromFile(File file); static URL fromJavaUrl(java.net.URL url); @Override boolean equals(Object obj); @Override int hashCode(); static Charset getURLEncoding(); java.net.URL toJavaURL(); @Override @SuppressWarnings("EmptyIfStmt") Problems getProblems(); @Override int compareTo(URL o); }### Answer: @Test public void testWithProtocol() { URL u = URL.parse("http: URL u2 = u.withProtocol(Protocols.WS); assertEquals(u.getPath(), u2.getPath()); assertNotEquals(u.getProtocol(), u2.getProtocol()); assertEquals(Protocols.HTTP, u.getProtocol()); assertEquals(Protocols.WS, u2.getProtocol()); }
### Question: ChainRunner { @Inject public ChainRunner(ExecutorService svc, ReentrantScope scope) { Checks.notNull("svc", svc); Checks.notNull("scope", scope); this.svc = svc; this.scope = scope; } @Inject ChainRunner(ExecutorService svc, ReentrantScope scope); void submit(P chain, ChainCallback<A, S, P, T, R> onDone, AtomicBoolean cancelled); }### Answer: @Test(timeout = 10000) public void testChainRunner() throws Exception, Throwable { AtomicBoolean cancelled = new AtomicBoolean(); ChainRunner cr = new ChainRunner(svc, scope); TestCallback chainWithDeferResults = new TestCallback(); TestCallback dontRespondChainResults = new TestCallback(); TestCallback plainChainResults = new TestCallback(); TestCallback errorChainResults = new TestCallback(); TestCallback rejectChainResults = new TestCallback(); TestCallback remnantChainResults = new TestCallback(); try (AutoCloseable cl = scope.enter()) { cr.submit(chain, chainWithDeferResults, cancelled); cr.submit(dontRespond, dontRespondChainResults, cancelled); cr.submit(plainChain, plainChainResults, cancelled); cr.submit(errorChain, errorChainResults, cancelled); cr.submit(rejectIt, rejectChainResults, cancelled); cr.submit(remnantChain, remnantChainResults, cancelled); cr.submit(remnantChain, remnantChainResults, cancelled); } chainWithDeferResults.assertGotResponse().assertActeurClass(AddedA.class).throwIfError().assertNotRejected(); dontRespondChainResults.assertNoResponse().throwIfError(); plainChainResults.throwIfError().assertGotResponse().assertActeurClass(AddedA.class).assertNotRejected(); errorChainResults.assertException(SpecialError.class); rejectChainResults.throwIfError().assertRejected(); remnantChainResults.throwIfError().assertRejected(); }
### Question: ChainRunner { public <A extends AbstractActeur<T, R, S>, S extends ActeurState<T, R>, P extends Chain<? extends A, ?>, T, R extends T> void submit(P chain, ChainCallback<A, S, P, T, R> onDone, AtomicBoolean cancelled) { ActeurInvoker<A, S, P, T, R> cc = new ActeurInvoker<>(svc, scope, chain, onDone, cancelled); try (QuietAutoCloseable ac = scope.enter(chain, cc.deferral)) { if (firstSync) { try { cc.call(); } catch (Exception ex) { Exceptions.chuck(ex); } } else { svc.submit(scope.wrap(cc)); } } } @Inject ChainRunner(ExecutorService svc, ReentrantScope scope); void submit(P chain, ChainCallback<A, S, P, T, R> onDone, AtomicBoolean cancelled); }### Answer: @Test(timeout = 20000) public void testMultiChainRunner() throws Exception, Throwable { AtomicBoolean cancelled = new AtomicBoolean(); List<ArrayChain<AbstractActeur<Response, ResponseImpl, ActeurState<Response, ResponseImpl>>, ?>> l = new LinkedList<>(); for (int i = 0; i < 5; i++) { ArrayChain<AbstractActeur<Response, ResponseImpl, ActeurState<Response, ResponseImpl>>, ?> ch = new NamedChain("Chain " + i, deps, AbstractActeur.class) .add(FirstA.class).add(Rejecter.class).add(SecondWithoutTimeoutA.class).add(EndA.class); l.add(ch); } l.add(plainChain); ChainsRunner cr = new ChainsRunner(svc, scope, new ChainRunner(svc, scope)); TestCallback callback = new TestCallback(); cr.submit(l, callback, cancelled); callback.throwIfError().assertNotRejected().assertGotResponse(); l.remove(l.size() - 1); callback = new TestCallback(); cr.submit(l, callback, cancelled); callback.throwIfError().assertNoResponse(); }
### Question: StrictTransportSecurityHeader extends AbstractHeader<StrictTransportSecurity> { @Override public StrictTransportSecurity toValue(CharSequence value) { return StrictTransportSecurity.parse(value); } StrictTransportSecurityHeader(); @Override StrictTransportSecurity toValue(CharSequence value); @Override CharSequence toCharSequence(StrictTransportSecurity value); }### Answer: @Test public void testStrictTransportHeader() { HeaderValueType<StrictTransportSecurity> h = new StrictTransportSecurityHeader(); assertEquals(StrictTransportSecurity.FIVE_YEARS_INCLUDE_SUBDOMAINS_PRELOAD, h.toValue(StrictTransportSecurity.FIVE_YEARS_INCLUDE_SUBDOMAINS_PRELOAD.toString())); assertEquals(StrictTransportSecurity.ONE_YEAR, h.toValue(StrictTransportSecurity.ONE_YEAR.toString())); }
### Question: CookieHeaderNetty428 extends AbstractHeader<Cookie[]> { @Override public Cookie[] toValue(CharSequence value) { ServerCookieDecoder decoder = strict ? ServerCookieDecoder.STRICT : ServerCookieDecoder.LAX; Set<Cookie> result = decoder.decode(notNull("value", value).toString()); return result == null ? EMPTY : result.toArray(new Cookie[result.size()]); } CookieHeaderNetty428(boolean strict); @Override CharSequence toCharSequence(Cookie[] value); @Override Cookie[] toValue(CharSequence value); }### Answer: @Test @SuppressWarnings("deprecation") public void testLegacyCookies() { CookieHeader h = new CookieHeader(); io.netty.handler.codec.http.DefaultCookie a = new io.netty.handler.codec.http.DefaultCookie("a", "a"); io.netty.handler.codec.http.DefaultCookie b = new io.netty.handler.codec.http.DefaultCookie("b", "b"); io.netty.handler.codec.http.DefaultCookie c = new io.netty.handler.codec.http.DefaultCookie("c", "c"); String val = h.toString(new io.netty.handler.codec.http.Cookie[]{a, b, c}); io.netty.handler.codec.http.Cookie[] result = h.toValue(val); assertNotNull(result); assertNotNull(val); assertTrue("Should contain all cookies:" + val, val.contains("a") && val.contains("b") && val.contains("c")); assertEquals(3, result.length); }
### Question: FrameOptions { public static FrameOptions allowFrom(URI uri) { return new FrameOptions(FrameOptionType.ALLOW_FROM, notNull("uri", uri)); } FrameOptions(FrameOptionType type); FrameOptions(FrameOptionType type, URI value); FrameOptionType type(); URI uri(); String name(); String toString(); static FrameOptions allowFrom(URI uri); static FrameOptions parse(CharSequence seq); boolean equals(Object o); int hashCode(); static final FrameOptions DENY; static final FrameOptions SAMEORIGIN; }### Answer: @Test public void testAllowFrom() { FrameOptions fo = FrameOptions.allowFrom(URI.create("http: assertEquals(URI.create("http: assertSame(FrameOptionType.ALLOW_FROM, fo.type()); assertEquals("ALLOW-FROM http: FrameOptions fo2 = FrameOptions.parse(fo.toString()); assertEquals(fo, fo2); assertEquals(fo.hashCode(), fo2.hashCode()); FrameOptions fo3 = FrameOptions.parse(fo.toString().toLowerCase()); assertEquals(fo, fo3); assertEquals(fo.hashCode(), fo3.hashCode()); assertEquals(fo.toString(), fo3.toString()); }
### Question: RotatingRealmProvider implements Provider<Realm> { @Override public Realm get() { Duration since1970 = Duration.ofMillis(System.currentTimeMillis()); long minutesSince1970 = since1970.toMinutes(); long intervals = minutesSince1970 / interval.toMinutes(); return new Realm(Strings.interleave(Long.toString(intervals, 36), salt)); } @Inject RotatingRealmProvider(Settings s); @Override Realm get(); static final String SETTINGS_KEY_ROTATE_INTERVAL_MINUTES; static final int DEFAULT_ROTATE_INTERVAL; }### Answer: @Test public void testDurationConversionWorks() { RotatingRealmProvider prov = new RotatingRealmProvider(Settings.EMPTY); Realm realm = prov.get(); assertEquals(realm, prov.get()); }
### Question: PagePathAndMethodFilter { public boolean match(HttpRequest req) { String path = this.basePathFilter.apply(req.uri()); if (path == null) { return false; } path = trimLeadingAndTrailingSlashes(trimQuery(path)); Method method = Method.get(req); MethodPath mp = new MethodPath(method, path); if (nonMatchesCache.contains(mp)) { return false; } if (matchesCache.contains(mp)) { return true; } ByMethod bm = all.get(mp.method); if (bm == null) { nonMatchesCache.add(mp); return false; } if (bm.match(mp.path)) { matchesCache.add(mp); return true; } else { nonMatchesCache.add(mp); return false; } } PagePathAndMethodFilter(Function<String, String> basePathFilter); PagePathAndMethodFilter(); PagePathAndMethodFilter(String basePath); @Override String toString(); boolean match(HttpRequest req); List<Object> listFor(HttpRequest req); }### Answer: @Test @SuppressWarnings("unchecked") public void testTypeMatching() { for (Class<?> c : classes) { Class<? extends Page> pg = (Class<? extends Page>) c; ShouldMatch shoulds = pg.getAnnotation(ShouldMatch.class); if (shoulds != null) { Method mth = pg.getAnnotation(Methods.class).value()[0]; for (String uri : shoulds.value()) { HttpRequest req = req(mth, uri); assertTrue(mth + " " + uri + " should be matched but isn't", pgs.match(req)); } } ShouldNotMatch shouldntss = pg.getAnnotation(ShouldNotMatch.class); if (shouldntss != null) { Method mth = pg.getAnnotation(Methods.class).value()[0]; for (String uri : shouldntss.value()) { HttpRequest req = req(mth, uri); assertFalse(mth + " " + uri + " should be matched but isn't", pgs.match(req)); } } } }
### Question: ValidationByResponseHandler { <T> Response validate(T object) { Set<ConstraintViolation<T>> errs = jeeValidator.validate(object); if (errs.isEmpty()) { return Response.status(200).entity(object).build(); } else { String msg = "Invalid Bean, constraint error(s) : "; for (ConstraintViolation<T> err : errs) { msg += err.getPropertyPath() + " " + err.getMessage() + ". "; } return Response.status(400).entity(msg).build(); } } }### Answer: @Test public void test_WHEN_valid_GIVEN_valid_model_THEN_ok_no_errors() { PersonModel person = new PersonModel( "Kim", "Kardashian", new GregorianCalendar(1980, Calendar.OCTOBER, 21)); ValidationByResponseHandler validator = new ValidationByResponseHandler(); Response response = validator.validate(person); assertThat(response.getStatus()).isEqualTo(200); } @Test public void test_WHEN_valid_GIVEN_invalid_model_THEN_error() { PersonModel person = new PersonModel( null, "", null); ValidationByResponseHandler validator = new ValidationByResponseHandler(); Response response = validator.validate(person); assertThat(response.getStatus()).isEqualTo(400); assertThat(response.getEntity().toString()) .contains("Invalid Bean, constraint error(s) : ") .contains("birthDate may not be null.") .contains("firstName may not be null.") .contains("lastName size must be between 1 and 16."); }
### Question: ValidationByExceptionHandler { <T> void validate(T object) { Set<ConstraintViolation<T>> errs = jeeValidator.validate(object); if (errs.size() > 0) { String msg = "Invalid Bean, constraint error(s) : "; for (ConstraintViolation<T> err : errs) { msg += err.getPropertyPath() + " " + err.getMessage() + ". "; } throw new IllegalArgumentException(msg); } } }### Answer: @Test public void test_WHEN_valid_GIVEN_valid_model_THEN_ok_no_errors() { PersonModel person = new PersonModel( "Kim", "Kardashian", new GregorianCalendar(1980, Calendar.OCTOBER, 21)); ValidationByExceptionHandler validator = new ValidationByExceptionHandler(); validator.validate(person); } @Test public void test_WHEN_valid_GIVEN_invalid_model_THEN_error() { PersonModel person = new PersonModel( null, "", null); ValidationByExceptionHandler validator = new ValidationByExceptionHandler(); try { validator.validate(person); fail(); } catch (IllegalArgumentException e) { assertThat(e.getMessage()) .contains("Invalid Bean, constraint error(s) : ") .contains("birthDate may not be null.") .contains("firstName may not be null.") .contains("lastName size must be between 1 and 16."); } }
### Question: HelloWorldBatch { public static void main(String[] args) { System.out.println("Executing batch"); if (args != null && args.length == 1 && args[0] != null) { System.out.println("input args ok"); } else { System.out.println("Error with input args"); throw new IllegalArgumentException("Error with input args"); } try { System.out.println("Executing job"); for (int i = 0; i < Integer.valueOf(args[0]); i++) { System.out.println("Hello World!"); } System.out.println("Ending job (success)"); } catch (Exception e) { System.out.println("Error during job (failure)"); System.out.println(e.getMessage()); throw new RuntimeException("Error during task (failure)", e); } System.out.println("Ending batch"); } static void main(String[] args); }### Answer: @Test public void test_batch_execution() { String[] args = { "10" }; HelloWorldBatch.main(args); } @Test public void test_args_validation() { try { HelloWorldBatch.main(null); fail("error expected"); } catch (IllegalArgumentException e) { } try { HelloWorldBatch.main(new String[] {}); fail("error expected"); } catch (IllegalArgumentException e) { } try { HelloWorldBatch.main(new String[] { null }); fail("error expected"); } catch (IllegalArgumentException e) { } } @Test(expected = RuntimeException.class) public void test_batch_execution_error() { HelloWorldBatch.main(new String[] { "ERROR" }); }
### Question: ProgressButton extends CompoundButton { public void setProgress(int progress) { if (progress > mMax \|\| progress < 0) { throw new IllegalArgumentException( String.format("Progress (%d) must be between %d and %d", progress, 0, mMax)); } mProgress = progress; invalidate(); } ProgressButton(Context context); ProgressButton(Context context, AttributeSet attrs); ProgressButton(Context context, AttributeSet attrs, int defStyle); int getMax(); void setMax(int max); int getProgress(); void setProgress(int progress); void setProgressAndMax(int progress, int max); int getProgressColor(); void setProgressColor(int progressColor); int getCircleColor(); void setCircleColor(int circleColor); Drawable getPinnedDrawable(); void setPinnedDrawable(Drawable pinnedDrawable); Drawable getUnpinnedDrawable(); void setUnpinnedDrawable(Drawable unpinnedDrawable); Drawable getShadowDrawable(); void setShadowDrawable(Drawable shadowDrawable); int getInnerSize(); void setInnerSize(int innerSize); boolean isPinned(); void setPinned(boolean pinned); boolean isAnimating(); int getAnimationSpeed(); int getAnimationDelay(); int getAnimationStripWidth(); void setAnimationSpeed(int animationSpeed); void setAnimationDelay(int animationDelay); void setAnimationStripWidth(int animationStripWidth); void startAnimating(); void stopAnimating(); @Override Parcelable onSaveInstanceState(); @Override void onRestoreInstanceState(Parcelable state); }### Answer: @Test public void invalidProgressValue() { try { button.setProgress(101); fail("Setting progress > max should throw"); } catch (IllegalArgumentException e) { } } @Test public void anotherInvalidProgressValue() { try { button.setProgress(-1); fail("Setting progress < 0 should throw"); } catch (IllegalArgumentException e) { } }
### Question: ProgressButton extends CompoundButton { public void setMax(int max) { if (max <= 0 \|\| max < mProgress) { throw new IllegalArgumentException( String.format("Max (%d) must be > 0 and >= %d", max, mProgress)); } mMax = max; invalidate(); } ProgressButton(Context context); ProgressButton(Context context, AttributeSet attrs); ProgressButton(Context context, AttributeSet attrs, int defStyle); int getMax(); void setMax(int max); int getProgress(); void setProgress(int progress); void setProgressAndMax(int progress, int max); int getProgressColor(); void setProgressColor(int progressColor); int getCircleColor(); void setCircleColor(int circleColor); Drawable getPinnedDrawable(); void setPinnedDrawable(Drawable pinnedDrawable); Drawable getUnpinnedDrawable(); void setUnpinnedDrawable(Drawable unpinnedDrawable); Drawable getShadowDrawable(); void setShadowDrawable(Drawable shadowDrawable); int getInnerSize(); void setInnerSize(int innerSize); boolean isPinned(); void setPinned(boolean pinned); boolean isAnimating(); int getAnimationSpeed(); int getAnimationDelay(); int getAnimationStripWidth(); void setAnimationSpeed(int animationSpeed); void setAnimationDelay(int animationDelay); void setAnimationStripWidth(int animationStripWidth); void startAnimating(); void stopAnimating(); @Override Parcelable onSaveInstanceState(); @Override void onRestoreInstanceState(Parcelable state); }### Answer: @Test public void setMaxToUnderZero() { try { button.setMax(-1); fail("Setting max <= 0 should throw"); } catch (IllegalArgumentException e) { } } @Test public void setMaxToZero() { try { button.setMax(0); fail("Setting max <= 0 should throw"); } catch (IllegalArgumentException e) { } }
### Question: ProgressButton extends CompoundButton { public void setPinned(boolean pinned) { setChecked(pinned); invalidate(); } ProgressButton(Context context); ProgressButton(Context context, AttributeSet attrs); ProgressButton(Context context, AttributeSet attrs, int defStyle); int getMax(); void setMax(int max); int getProgress(); void setProgress(int progress); void setProgressAndMax(int progress, int max); int getProgressColor(); void setProgressColor(int progressColor); int getCircleColor(); void setCircleColor(int circleColor); Drawable getPinnedDrawable(); void setPinnedDrawable(Drawable pinnedDrawable); Drawable getUnpinnedDrawable(); void setUnpinnedDrawable(Drawable unpinnedDrawable); Drawable getShadowDrawable(); void setShadowDrawable(Drawable shadowDrawable); int getInnerSize(); void setInnerSize(int innerSize); boolean isPinned(); void setPinned(boolean pinned); boolean isAnimating(); int getAnimationSpeed(); int getAnimationDelay(); int getAnimationStripWidth(); void setAnimationSpeed(int animationSpeed); void setAnimationDelay(int animationDelay); void setAnimationStripWidth(int animationStripWidth); void startAnimating(); void stopAnimating(); @Override Parcelable onSaveInstanceState(); @Override void onRestoreInstanceState(Parcelable state); }### Answer: @Test public void onCheckedChangeListenerIsNotified() { CompoundButton.OnCheckedChangeListener publisher = mock(CompoundButton.OnCheckedChangeListener.class); button.setOnCheckedChangeListener(publisher); button.setPinned(true); verify(publisher).onCheckedChanged(button, true); button.setPinned(false); verify(publisher).onCheckedChanged(button, false); } @Test public void onCheckedChangeListenerIsNotifiedOnToggle() { button.setPinned(true); CompoundButton.OnCheckedChangeListener publisher = mock(CompoundButton.OnCheckedChangeListener.class); button.setOnCheckedChangeListener(publisher); button.toggle(); verify(publisher).onCheckedChanged(button, false); }
### Question: ProgressButton extends CompoundButton { @Override public Parcelable onSaveInstanceState() { Parcelable superState = super.onSaveInstanceState(); if (isSaveEnabled()) { SavedState ss = new SavedState(superState); ss.mMax = mMax; ss.mProgress = mProgress; return ss; } return superState; } ProgressButton(Context context); ProgressButton(Context context, AttributeSet attrs); ProgressButton(Context context, AttributeSet attrs, int defStyle); int getMax(); void setMax(int max); int getProgress(); void setProgress(int progress); void setProgressAndMax(int progress, int max); int getProgressColor(); void setProgressColor(int progressColor); int getCircleColor(); void setCircleColor(int circleColor); Drawable getPinnedDrawable(); void setPinnedDrawable(Drawable pinnedDrawable); Drawable getUnpinnedDrawable(); void setUnpinnedDrawable(Drawable unpinnedDrawable); Drawable getShadowDrawable(); void setShadowDrawable(Drawable shadowDrawable); int getInnerSize(); void setInnerSize(int innerSize); boolean isPinned(); void setPinned(boolean pinned); boolean isAnimating(); int getAnimationSpeed(); int getAnimationDelay(); int getAnimationStripWidth(); void setAnimationSpeed(int animationSpeed); void setAnimationDelay(int animationDelay); void setAnimationStripWidth(int animationStripWidth); void startAnimating(); void stopAnimating(); @Override Parcelable onSaveInstanceState(); @Override void onRestoreInstanceState(Parcelable state); }### Answer: @Test public void onSaveInstanceState() { button.setProgress(72); button.setMax(842); final Parcelable parcelable = button.onSaveInstanceState(); button.setProgress(2); button.setMax(50); assertThat(button.getProgress()).isEqualTo(2); assertThat(button.getMax()).isEqualTo(50); button.onRestoreInstanceState(parcelable); assertThat(button.getProgress()).isEqualTo(72); assertThat(button.getMax()).isEqualTo(842); }
### Question: ProgressButton extends CompoundButton { public void setProgressAndMax(int progress, int max) { if (progress > max \|\| progress < 0) { throw new IllegalArgumentException( String.format("Progress (%d) must be between %d and %d", progress, 0, max)); } else if (max <= 0) { throw new IllegalArgumentException(String.format("Max (%d) must be > 0", max)); } mProgress = progress; mMax = max; invalidate(); } ProgressButton(Context context); ProgressButton(Context context, AttributeSet attrs); ProgressButton(Context context, AttributeSet attrs, int defStyle); int getMax(); void setMax(int max); int getProgress(); void setProgress(int progress); void setProgressAndMax(int progress, int max); int getProgressColor(); void setProgressColor(int progressColor); int getCircleColor(); void setCircleColor(int circleColor); Drawable getPinnedDrawable(); void setPinnedDrawable(Drawable pinnedDrawable); Drawable getUnpinnedDrawable(); void setUnpinnedDrawable(Drawable unpinnedDrawable); Drawable getShadowDrawable(); void setShadowDrawable(Drawable shadowDrawable); int getInnerSize(); void setInnerSize(int innerSize); boolean isPinned(); void setPinned(boolean pinned); boolean isAnimating(); int getAnimationSpeed(); int getAnimationDelay(); int getAnimationStripWidth(); void setAnimationSpeed(int animationSpeed); void setAnimationDelay(int animationDelay); void setAnimationStripWidth(int animationStripWidth); void startAnimating(); void stopAnimating(); @Override Parcelable onSaveInstanceState(); @Override void onRestoreInstanceState(Parcelable state); }### Answer: @Test public void settingInvalidProgressAndMax() { try { button.setProgressAndMax(10, 5); fail("Setting progress > max should throw"); } catch (IllegalArgumentException e) { } try { button.setProgressAndMax(0, 0); fail("Setting max = 0 should throw"); } catch (IllegalArgumentException e) { } try { button.setProgressAndMax(-1, 10); fail("Setting progress < 0 should throw"); } catch (IllegalArgumentException e) { } }
### Question: WriteController { @RequestMapping(value = "/{id}", method = RequestMethod.DELETE) @ResponseStatus(value = HttpStatus.OK) public void delete(@PathVariable(value = "id") String id, HttpServletResponse response) throws IOException { service.delete(id); } @RequestMapping(value = "/create", method = RequestMethod.POST) @ResponseStatus(value = HttpStatus.OK) @ResponseBody String create(@RequestParam("comment") final String comment, @RequestParam("pageId") final String pageId, @RequestParam("emailAddress") final String emailAddress, @RequestParam("username") final String username); @RequestMapping(value = "/{id}", method = RequestMethod.DELETE) @ResponseStatus(value = HttpStatus.OK) void delete(@PathVariable(value = "id") String id, HttpServletResponse response); @ExceptionHandler(EmptyResultDataAccessException.class) @ResponseStatus(value = HttpStatus.NOT_FOUND) void handle404(Exception ex, Locale locale); }### Answer: @Test public void testDelete() throws Exception { CommentModel model = new CommentModel(); model.setUsername("testuser"); model.setId("dqe345e456rf34rw"); model.setPageId("product0815"); model.setEmailAddress("[email protected]"); model.setComment("I am the comment"); String id = service.put(model); this.mvc.perform(delete("/" + id)).andExpect(status().isOk()); assertNull(service.get(model.getId())); }
### Question: ReadController { @RequestMapping(value = "/listspam/{id}") public List<CommentDTO> getSpamComments(@PathVariable(value = "id") String pageId) throws IOException { LOGGER.info("get spam comments for pageId {}", pageId); counterService.increment("commentstore.list_spamcomments"); List<CommentModel> r = service.listSpamComments(pageId); LOGGER.info("get spam comments for pageId {} - done", pageId); return transformToDTO(r); } @RequestMapping(value = "/list/{id}") List<CommentDTO> getComments(@PathVariable(value = "id") String pageId); @RequestMapping(value = "/listspam/{id}") List<CommentDTO> getSpamComments(@PathVariable(value = "id") String pageId); @RequestMapping(value = "/{id}", method=RequestMethod.GET, produces = { MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE }) CommentDTO getComment(@PathVariable(value = "id") String commentId); @RequestMapping(value = "/comments") Page<CommentModel> listComments(@RequestParam(name="page", required=false) String pageIn, @RequestParam(name="size", required=false) String pageSizeIn); @ExceptionHandler(FileNotFoundException.class) @ResponseStatus(value = HttpStatus.NOT_FOUND) void handle404(Exception ex, Locale locale); }### Answer: @Test public void testGetSpamComments() throws Exception { CommentModel model = setupDummyModel(); List<CommentModel> mockReturn = new ArrayList<CommentModel>(); mockReturn.add(model); when(this.commentService.list( anyString())).thenReturn(mockReturn); this.mvc.perform(get("/listspam/" + model.getPageId())) .andExpect(status().is(200)) .andExpect(jsonPath("$", hasSize(0))); ; }
### Question: Logger { public static void addLogPrinter(AbstractLogPrinter logPrinter) { if (logPrinter == null) throw new NullPointerException("logPrinter is null"); logAdapter.add(logPrinter); } private Logger(); static void addLogPrinter(AbstractLogPrinter logPrinter); static void removeLogPrint(AbstractLogPrinter logPrinter); static void clearLogPrint(); static void v(String msg, Object...args); static void v(String msg, Throwable tr, Object...args); static void d(String msg, Object...args); static void d(String msg, Throwable tr, Object...args); static void i(String msg, Object...args); static void i(String msg, Throwable tr, Object...args); static void w(String msg, Object...args); static void w(String msg, Throwable tr, Object...args); static void w(Throwable tr, Object...args); static void e(String msg, Object...args); static void e(String msg, Throwable tr, Object...args); static void e(Throwable tr, Object...args); static void d(Object object); static void json(String json); static void json(String name, String json); }### Answer: @Test(expected = NullPointerException.class) public void nullAddLogPrinter() { Logger.addLogPrinter(null); }
### Question: Logger { public static void removeLogPrint(AbstractLogPrinter logPrinter) { if (logPrinter == null) throw new NullPointerException("logPrinter is null"); logAdapter.remove(logPrinter); } private Logger(); static void addLogPrinter(AbstractLogPrinter logPrinter); static void removeLogPrint(AbstractLogPrinter logPrinter); static void clearLogPrint(); static void v(String msg, Object...args); static void v(String msg, Throwable tr, Object...args); static void d(String msg, Object...args); static void d(String msg, Throwable tr, Object...args); static void i(String msg, Object...args); static void i(String msg, Throwable tr, Object...args); static void w(String msg, Object...args); static void w(String msg, Throwable tr, Object...args); static void w(Throwable tr, Object...args); static void e(String msg, Object...args); static void e(String msg, Throwable tr, Object...args); static void e(Throwable tr, Object...args); static void d(Object object); static void json(String json); static void json(String name, String json); }### Answer: @Test(expected = NullPointerException.class) public void nullRemoveLogPrinter() { Logger.removeLogPrint(null); }
### Question: Logger { public static void d(String msg, Object...args) { logAdapter.d(msg, args); } private Logger(); static void addLogPrinter(AbstractLogPrinter logPrinter); static void removeLogPrint(AbstractLogPrinter logPrinter); static void clearLogPrint(); static void v(String msg, Object...args); static void v(String msg, Throwable tr, Object...args); static void d(String msg, Object...args); static void d(String msg, Throwable tr, Object...args); static void i(String msg, Object...args); static void i(String msg, Throwable tr, Object...args); static void w(String msg, Object...args); static void w(String msg, Throwable tr, Object...args); static void w(Throwable tr, Object...args); static void e(String msg, Object...args); static void e(String msg, Throwable tr, Object...args); static void e(Throwable tr, Object...args); static void d(Object object); static void json(String json); static void json(String name, String json); }### Answer: @Test public void dontAddLogPrinter() { String message = "Hello, world!"; Logger.d(message); assertLog() .hasNoMoreMessages(); }
### Question: Decorator implements Component { @Override public double calc(String user ,int seniority) { return this.component.calc(user ,seniority); } Decorator(Component component); @Override double calc(String user ,int seniority); }### Answer: @Test public void test() { String user = "zlikun" ; int seniority = 7 ; Component component = new ComponetImpl() ; Assert.assertEquals(0 ,component.calc(user ,seniority) ,0); Decorator d1 = new MonthDecorator(component) ; Assert.assertEquals(1000 ,d1.calc(user ,seniority) ,0); Decorator d2 = new YearDecorator(d1) ; Assert.assertEquals(3000 ,d2.calc(user ,seniority) ,0); }
### Question: Singleton2 { public static final Singleton2 getInstance() { if (INSTANCE == null) { INSTANCE = new Singleton2() ; } return INSTANCE ; } Singleton2(); static final Singleton2 getInstance(); }### Answer: @Test public void test_multi() { final ConcurrentMap<Singleton2 ,Boolean> map = new ConcurrentHashMap<>() ; ExecutorService exec = Executors.newFixedThreadPool(200) ; final long moment = System.currentTimeMillis() + 1000 ; for (int i = 0; i < 1000; i++) { exec.execute(new Runnable() { @Override public void run() { while (true) { if (moment < System.currentTimeMillis()) { map.put(Singleton2.getInstance() ,Boolean.TRUE) ; break; } } } }); } exec.shutdown(); while (!exec.isTerminated()) ; Assert.assertTrue(map.size() > 1); } @Test public void test_single() { Assert.assertTrue(Singleton2.getInstance() == Singleton2.getInstance()); Assert.assertTrue(new Singleton2() != new Singleton2()); }
### Question: TrainFactory { public String process() { StringBuilder sb = new StringBuilder() ; sb.append(builder.buildHeader()).append("-") ; sb.append(builder.buildBody()).append("-") ; sb.append(builder.buildFooter()) ; return sb.toString() ; } TrainFactory(TrainBuilder builder); String process(); }### Answer: @Test public void test() { TrainFactory factory = new TrainFactory(new TrainBuilder()) ; String train = factory.process() ; Assert.assertEquals("火车头-火车身-火车尾" ,train); }
### Question: Singleton0 { public static final Singleton0 getInstance() { return INSTANCE ; } private Singleton0(); static final Singleton0 getInstance(); }### Answer: @Test public void test_single() { Assert.assertTrue(Singleton0.getInstance() == Singleton0.getInstance()); } @Test public void test_multi() { final Set<Singleton0> set = new HashSet<>() ; ExecutorService exec = Executors.newFixedThreadPool(50) ; for (int i = 0; i < 1000; i++) { exec.execute(new Runnable() { @Override public void run() { set.add(Singleton0.getInstance()) ; } }); } exec.shutdown(); while (!exec.isTerminated()) ; Assert.assertEquals(1 ,set.size()); }
### Question: Singleton5 { public static final Singleton5 getInstance() { if (INSTANCE == null) { try { if (LOCK.tryLock(100 , TimeUnit.MILLISECONDS)) { if (INSTANCE == null) { INSTANCE = new Singleton5(); } } } catch (InterruptedException e) { e.printStackTrace(); } finally { LOCK.unlock(); } } return INSTANCE ; } private Singleton5(); static final Singleton5 getInstance(); }### Answer: @Test public void test_single() { Assert.assertTrue(Singleton5.getInstance() == Singleton5.getInstance()); } @Test public void test_multi() { final ConcurrentMap<Singleton5 ,Boolean> map = new ConcurrentHashMap<>() ; ExecutorService exec = Executors.newFixedThreadPool(400) ; final long moment = System.currentTimeMillis() + 1000 ; for (int i = 0; i < 1000; i++) { exec.execute(new Runnable() { @Override public void run() { while (true) { if (moment < System.currentTimeMillis()) { map.put(Singleton5.getInstance() ,Boolean.TRUE) ; break; } } } }); } exec.shutdown(); while (!exec.isTerminated()) ; Assert.assertEquals(1 ,map.size()); }
### Question: Singleton3 { public static final Singleton3 getInstance() { if (INSTANCE == null) { synchronized (Singleton3.class) { if (INSTANCE == null) { INSTANCE = new Singleton3() ; } } } return INSTANCE ; } private Singleton3(); static final Singleton3 getInstance(); }### Answer: @Test public void test_single() { Assert.assertTrue(Singleton3.getInstance() == Singleton3.getInstance()); } @Test public void test_multi() { final ConcurrentMap<Singleton3 ,Boolean> map = new ConcurrentHashMap<>() ; ExecutorService exec = Executors.newFixedThreadPool(400) ; final long moment = System.currentTimeMillis() + 1000 ; for (int i = 0; i < 1000; i++) { exec.execute(new Runnable() { @Override public void run() { while (true) { if (moment < System.currentTimeMillis()) { map.put(Singleton3.getInstance() ,Boolean.TRUE) ; break; } } } }); } exec.shutdown(); while (!exec.isTerminated()) ; Assert.assertEquals(1 ,map.size()); }
### Question: Singleton4 { public static final Singleton4 getInstance() { if (INSTANCE == null) { INSTANCE = Singleton4Holder.obj ; } return INSTANCE ; } private Singleton4(); static final Singleton4 getInstance(); }### Answer: @Test public void test_single() { Assert.assertTrue(Singleton4.getInstance() == Singleton4.getInstance()); } @Test public void test_multi() { final ConcurrentMap<Singleton4 ,Boolean> map = new ConcurrentHashMap<>() ; ExecutorService exec = Executors.newFixedThreadPool(400) ; final long moment = System.currentTimeMillis() + 1000 ; for (int i = 0; i < 1000; i++) { exec.execute(new Runnable() { @Override public void run() { while (true) { if (moment < System.currentTimeMillis()) { map.put(Singleton4.getInstance() ,Boolean.TRUE) ; break; } } } }); } exec.shutdown(); while (!exec.isTerminated()) ; Assert.assertEquals(1 ,map.size()); }
### Question: QueryParser { public Collection<String> parseFeatures() { String featureValues = kvps.get(FEATURES.name()); return parseCommaSeparatedValues(featureValues); } QueryParser(String query, boolean compressed); Collection<String> parseServices(); Collection<String> parseVersions(); Collection<String> parseFeatures(); Collection<String> parseOfferings(); Collection<String> parseProcedures(); Collection<String> parsePhenomenons(); TimeRange parseTimeRange(); }### Answer: @Test public void testParseStationKvp() { StringBuilder validQuery = new StringBuilder(); validQuery.append("features=").append("Heldra_41700105"); QueryParser parser = new QueryParser(validQuery.toString(), false); Collection<String> parsedStations = parser.parseFeatures(); assertTrue("Invalid size: " + parsedStations.size(), parsedStations.size() == 1); assertTrue("Stations could not be parsed.", parsedStations.contains("Heldra_41700105")); }
### Question: QueryParser { public Collection<String> parsePhenomenons() { String phenomenonValues = kvps.get(PHENOMENONS.name()); return parseCommaSeparatedValues(phenomenonValues); } QueryParser(String query, boolean compressed); Collection<String> parseServices(); Collection<String> parseVersions(); Collection<String> parseFeatures(); Collection<String> parseOfferings(); Collection<String> parseProcedures(); Collection<String> parsePhenomenons(); TimeRange parseTimeRange(); }### Answer: @Test public void testParsePhenomenonsKvp() { StringBuilder validQuery = new StringBuilder(); validQuery.append("phenomenons=").append("Wasserstand"); QueryParser parser = new QueryParser(validQuery.toString(), false); Collection<String> parsedPhenomenons = parser.parsePhenomenons(); assertTrue("Invalid size: " + parsedPhenomenons.size(), parsedPhenomenons.size() == 1); assertTrue("Stations could not be parsed.", parsedPhenomenons.contains("Wasserstand")); }
### Question: QueryParser { public Collection<String> parseProcedures() { String procedureValues = kvps.get(PROCEDURES.name()); return parseCommaSeparatedValues(procedureValues); } QueryParser(String query, boolean compressed); Collection<String> parseServices(); Collection<String> parseVersions(); Collection<String> parseFeatures(); Collection<String> parseOfferings(); Collection<String> parseProcedures(); Collection<String> parsePhenomenons(); TimeRange parseTimeRange(); }### Answer: @Test public void testParseProceduresKvp() { StringBuilder validQuery = new StringBuilder(); validQuery.append("procedures=").append("Wasserstand-Heldra_41700105"); QueryParser parser = new QueryParser(validQuery.toString(), false); Collection<String> parsedProcedures = parser.parseProcedures(); assertTrue("Invalid size: " + parsedProcedures.size(), parsedProcedures.size() == 1); assertTrue("Stations could not be parsed.", parsedProcedures.contains("Wasserstand-Heldra_41700105")); }
### Question: QueryParser { public TimeRange parseTimeRange() { String begin = kvps.get(BEGIN.name()); String end = kvps.get(END.name()); return TimeRange.createTimeRange(begin, end); } QueryParser(String query, boolean compressed); Collection<String> parseServices(); Collection<String> parseVersions(); Collection<String> parseFeatures(); Collection<String> parseOfferings(); Collection<String> parseProcedures(); Collection<String> parsePhenomenons(); TimeRange parseTimeRange(); }### Answer: @Test public void testParsingBeginAndEndKvps() { StringBuilder validQuery = new StringBuilder(); validQuery.append("begin"); validQuery.append("="); validQuery.append("2012-10-01T12:01:00"); validQuery.append("&"); validQuery.append("end"); validQuery.append("="); validQuery.append("2014-10-01T12:01:00"); QueryParser parser = new QueryParser(validQuery.toString(), false); TimeRange parsedTimeRange = parser.parseTimeRange(); assertEquals("2012-10-01T12:01:00", parsedTimeRange.getStart()); assertEquals("2014-10-01T12:01:00", parsedTimeRange.getEnd()); }
### Question: XmlHelper { public <T> T parseFirst(XmlObject from, String xPath, Class<T> ofType) { T[] results = parseAll(from, xPath, ofType); return results.length > 0 ? results[0] : null; } XmlHelper(Map<String, String> namespaceDecarations); String getShortName(IdentifierList identifiers); String getUniqueId(IdentifierList identifiers); String[] getRelatedFeatures(Capabilities identifiers); PointDocument getPoint(FeaturePropertyType member, CRSUtils referenceHelper); String[] getRelatedPhenomena(Outputs outputs); T parseFirst(XmlObject from, String xPath, Class<T> ofType); @SuppressWarnings("unchecked") T[] parseAll(XmlObject from, String xPath, Class<T> ofType); }### Answer: @Test public void shouldParseSystemViaXPath() { SystemType systemType = xmlHelper.parseFirst(smlDoc, "$this assertNotNull(systemType); }
### Question: SosMetadataUpdate { protected static String createPostfix(String url) { if (url.startsWith("http: url = url.substring("http: } return url.replaceAll("/", "_").replaceAll("\\?", "_").replaceAll(":", "_").replaceAll("@", "_"); } static void updateSosServices(Iterable<String> sosServices); static void updateService(String serviceUrl); static void invalidateCache(); }### Answer: @Test public void testCreatePostfix() { String postfix = SosMetadataUpdate.createPostfix(validServiceUrl); assertEquals("my.server.net_52n-SOS-Vx.x_sos", postfix); }
### Question: SosMetadataUpdate { protected static File getCacheTarget(String serviceUrl) { String postfix = createPostfix(serviceUrl); return new File(generateCacheFilePath(postfix)); } static void updateSosServices(Iterable<String> sosServices); static void updateService(String serviceUrl); static void invalidateCache(); }### Answer: @Test public void testGetCacheTarget() { File expected = new File(cacheTargetFile); File cacheTarget = SosMetadataUpdate.getCacheTarget(validServiceUrl); assertEquals(expected.getAbsoluteFile(), cacheTarget.getAbsoluteFile()); }
### Question: SosMetadataUpdate { protected static void prepareCacheTargetDirectory() throws IOException { File cacheDirectory = getCacheDir(); if (!cacheDirectory.exists() && !cacheDirectory.mkdirs()) { throw new IOException("Unable to create cache directory."); } } static void updateSosServices(Iterable<String> sosServices); static void updateService(String serviceUrl); static void invalidateCache(); }### Answer: @Test public void testPrepareCacheTarget() throws IOException { SosMetadataUpdate.prepareCacheTargetDirectory(); assertTrue(temporalCacheDirectory.exists()); }
### Question: SOSRequestBuilderGET_200 implements ISOSRequestBuilder { String encodePlusInParameter(String parameter) { return parameter.replace("+", "%2B"); } @Override String buildGetCapabilitiesRequest(ParameterContainer parameters); @Override String buildGetObservationRequest(ParameterContainer parameters); @Override String buildDescribeSensorRequest(ParameterContainer parameters); @Override String buildGetFeatureOfInterestRequest(ParameterContainer parameters); String encode(String parameter); @Override String buildGetObservationByIDRequest(ParameterContainer parameters); @Override String buildInsertObservation(ParameterContainer parameters); @Override String buildRegisterSensor(ParameterContainer parameters); }### Answer: @Test public void testEncodePlusInParameter() { String encoded = builder.encodePlusInParameter("a string with a \"+\""); assertEquals("a string with a \"%2B\"", encoded); }
### Question: SOSRequestBuilderGET_200 implements ISOSRequestBuilder { String fixTimeZone(String timeString) { StringBuilder sb = new StringBuilder(timeString); int insertionIndex = timeString.length() - 2; if (sb.charAt(insertionIndex - 1) != ':') { sb.insert(insertionIndex, ":"); } return sb.toString(); } @Override String buildGetCapabilitiesRequest(ParameterContainer parameters); @Override String buildGetObservationRequest(ParameterContainer parameters); @Override String buildDescribeSensorRequest(ParameterContainer parameters); @Override String buildGetFeatureOfInterestRequest(ParameterContainer parameters); String encode(String parameter); @Override String buildGetObservationByIDRequest(ParameterContainer parameters); @Override String buildInsertObservation(ParameterContainer parameters); @Override String buildRegisterSensor(ParameterContainer parameters); }### Answer: @Test public void testFixTimeZone() { String incorrectTime = "2012-08-06T13:49:30.0+0200"; String correctTime = builder.fixTimeZone(incorrectTime); assertEquals("2012-08-06T13:49:30.0+02:00", correctTime); }
### Question: SOSRequestBuilderGET_200 implements ISOSRequestBuilder { public String encode(String parameter) { try { return encodePlusInParameter(URLEncoder.encode(parameter, "utf-8")); } catch (UnsupportedEncodingException e) { LOGGER.warn("Could not encode parameter {}!", parameter); return parameter; } } @Override String buildGetCapabilitiesRequest(ParameterContainer parameters); @Override String buildGetObservationRequest(ParameterContainer parameters); @Override String buildDescribeSensorRequest(ParameterContainer parameters); @Override String buildGetFeatureOfInterestRequest(ParameterContainer parameters); String encode(String parameter); @Override String buildGetObservationByIDRequest(ParameterContainer parameters); @Override String buildInsertObservation(ParameterContainer parameters); @Override String buildRegisterSensor(ParameterContainer parameters); }### Answer: @Test public void testEncodeParameter() { String encoded = builder.encode("2012-08-06T13:49:30.0+02:00"); assertEquals("2012-08-06T13%3A49%3A30.0%2B02%3A00", encoded); String encodedCharacters = builder.encode("#$&'()+,/:;=?@[]"); assertEquals("%23%24%26%27%28%29%2B%2C%2F%3A%3B%3D%3F%40%5B%5D", encodedCharacters); }
### Question: SOSRequestBuilderGET_200 implements ISOSRequestBuilder { String createIso8601Duration(String start, String end) { StringBuilder sb = new StringBuilder(); sb.append(fixTimeZone(start)).append("/"); return sb.append(fixTimeZone(end)).toString(); } @Override String buildGetCapabilitiesRequest(ParameterContainer parameters); @Override String buildGetObservationRequest(ParameterContainer parameters); @Override String buildDescribeSensorRequest(ParameterContainer parameters); @Override String buildGetFeatureOfInterestRequest(ParameterContainer parameters); String encode(String parameter); @Override String buildGetObservationByIDRequest(ParameterContainer parameters); @Override String buildInsertObservation(ParameterContainer parameters); @Override String buildRegisterSensor(ParameterContainer parameters); }### Answer: @Test public void testCreateIso8601Duration() { String start = "2012-08-06T13:49:30.0+02:00"; String end = "2012-08-01T13:49:30.0+02:00"; String duration = builder.createIso8601Duration(start, end); assertEquals("2012-08-06T13:49:30.0+02:00/2012-08-01T13:49:30.0+02:00", duration); }
### Question: ClientUtils { public static String[] splitJsonObjects(String value) { int openCurlies = 0; List<String> objects = new ArrayList<String>(); StringBuilder object = new StringBuilder(); for (int i=0; i < value.length() ; i++) { char currentChar = value.charAt(i); object.append(currentChar); if (currentChar == '{') { openCurlies++; } if (currentChar == '}') { openCurlies--; } if (openCurlies == 0) { objects.add(object.toString()); object = new StringBuilder(); i++; } } return objects.toArray(new String[0]); } private ClientUtils(); static String getRandomHexColor(); static boolean isValidTimeFrameForZoomIn(long begin, long end); static String[] getDecodedParameters(PermalinkParameter parameter); static String[] getDecodedParameters(String parameter); static String[] splitJsonObjects(String value); static boolean isSesEnabled(); }### Answer: @Test public void shouldReadEmptyJson() { assertThat(splitJsonObjects("{}").length, is(1)); } @Test public void shouldReadSingleJsonObject() { assertThat(splitJsonObjects("{\"parameter\":\"value\"}").length, is(1)); } @Test public void shouldReadMultipleJsonObject() { assertThat(splitJsonObjects("{\"parameter\":\"value\"},{\\\"parameter\\\":\\\"value\\\"}").length, is(2)); } @Test public void shouldReturnEmptyArrayIfInvalid() { assertThat(splitJsonObjects("{\"parameter\":\"value\"").length, is(0)); }
### Question: QueryBuilder { String encodeValue(String value) { value = value.replace("%", "%25"); value = value.replace("+", "%2B"); value = value.replace(" ", "+"); value = value.replace("!", "%21"); value = value.replace("#", "%23"); value = value.replace("$", "%24"); value = value.replace("&", "%26"); value = value.replace("'", "%27"); value = value.replace("(", "%28"); value = value.replace(")", "%29"); value = value.replace(",", "%2C"); value = value.replace("/", "%2F"); value = value.replace(":", "%3A"); value = value.replace(";", "%3B"); value = value.replace("=", "%3D"); value = value.replace("?", "%3F"); value = value.replace("@", "%40"); value = value.replace("[", "%5B"); value = value.replace("]", "%5D"); return value; } void removeLastComma(StringBuilder builder); int length(); void appendCompressedParameter(); StringBuilder initialize(String baseUrl); @Override String toString(); }### Answer: @Test public void testEncodeValues() { queryBuilder = new QueryBuilder(); assertEquals("value+with+spaces", queryBuilder.encodeValue("value with spaces")); assertEquals("value%2Cwith%2Ccommas", queryBuilder.encodeValue("value,with,commas")); assertEquals("value+with+spaces%2Bplus+sign", queryBuilder.encodeValue("value with spaces+plus sign")); assertEquals("%21+%23+%24", queryBuilder.encodeValue("! # $")); assertEquals("%25+%26+%27+%28", queryBuilder.encodeValue("% & ' (")); assertEquals("%26+%27+%25+%28", queryBuilder.encodeValue("& ' % (")); }
### Question: EventSubscriptionController { String replaceNonAlphaNumerics(String toReplace) { return toReplace.replaceAll("[^0-9a-zA-Z_]", "_"); } void setTimeseries(TimeseriesLegendData timeseries); TimeseriesLegendData getTimeSeries(); String getServiceUrl(); String getOffering(); String getPhenomenon(); String getProcedure(); String getFeatureOfInterest(); void setSelectedAbonnementName(String currentAbonnementName); String getSelectedAbonnementName(); boolean isSelectionValid(); void setSelectedSubscriptionTemplate(SubscriptionTemplate template); void updateSelectedRuleTemplate(SubscriptionTemplate template); String createSuggestedAbonnementName(); SimpleRuleType getSelectedRuleTemplate(); OverUndershootSelectionData getOverUndershootEntryConditions(); OverUndershootSelectionData getOverUndershootExitConditions(); SensorLossSelectionData getSensorLossConditions(); void clearSelectionData(); Rule createSimpleRuleFromSelection(); }### Answer: @Test public void shouldReplaceAllNonAlphaNumericsWithUnderscore() { assertThat(controllerUnderTest.replaceNonAlphaNumerics("#'+`´^°!§$%&/()=?-"), is("__________________")); } @Test public void shouldNotReplaceAlphaNumericsWithUnderscores() { assertThat(controllerUnderTest.replaceNonAlphaNumerics("ABCNksdfjiu098723049234lkjdsf"), is("ABCNksdfjiu098723049234lkjdsf")); }
### Question: EventSubscriptionController { String replaceAllUmlauts(String toReplace) { toReplace = toReplace.replaceAll("[ö]", "oe"); toReplace = toReplace.replaceAll("^Ö", "Oe"); toReplace = toReplace.replaceAll("[Ö]", "OE"); toReplace = toReplace.replaceAll("[ä]", "ae"); toReplace = toReplace.replaceAll("^Ä", "Ae"); toReplace = toReplace.replaceAll("[Ä]", "AE"); toReplace = toReplace.replaceAll("[ü]", "ue"); toReplace = toReplace.replaceAll("^Ü", "Ue"); toReplace = toReplace.replaceAll("[Ü]", "UE"); toReplace = toReplace.replaceAll("[ß]", "ss"); return toReplace; } void setTimeseries(TimeseriesLegendData timeseries); TimeseriesLegendData getTimeSeries(); String getServiceUrl(); String getOffering(); String getPhenomenon(); String getProcedure(); String getFeatureOfInterest(); void setSelectedAbonnementName(String currentAbonnementName); String getSelectedAbonnementName(); boolean isSelectionValid(); void setSelectedSubscriptionTemplate(SubscriptionTemplate template); void updateSelectedRuleTemplate(SubscriptionTemplate template); String createSuggestedAbonnementName(); SimpleRuleType getSelectedRuleTemplate(); OverUndershootSelectionData getOverUndershootEntryConditions(); OverUndershootSelectionData getOverUndershootExitConditions(); SensorLossSelectionData getSensorLossConditions(); void clearSelectionData(); Rule createSimpleRuleFromSelection(); }### Answer: @Test public void shouldReplaceAllUmlautsWithAlternatives() { assertThat(controllerUnderTest.replaceAllUmlauts("ÜüÖöÄäß"), is("UeueOEoeAEaess")); }
### Question: EventSubscriptionController { String normalize(String toNormalize) { return replaceNonAlphaNumerics(replaceAllUmlauts(toNormalize)); } void setTimeseries(TimeseriesLegendData timeseries); TimeseriesLegendData getTimeSeries(); String getServiceUrl(); String getOffering(); String getPhenomenon(); String getProcedure(); String getFeatureOfInterest(); void setSelectedAbonnementName(String currentAbonnementName); String getSelectedAbonnementName(); boolean isSelectionValid(); void setSelectedSubscriptionTemplate(SubscriptionTemplate template); void updateSelectedRuleTemplate(SubscriptionTemplate template); String createSuggestedAbonnementName(); SimpleRuleType getSelectedRuleTemplate(); OverUndershootSelectionData getOverUndershootEntryConditions(); OverUndershootSelectionData getOverUndershootExitConditions(); SensorLossSelectionData getSensorLossConditions(); void clearSelectionData(); Rule createSimpleRuleFromSelection(); }### Answer: @Test public void shouldNormalizeUmlautsAndNonAlphaNumerics() { assertThat(controllerUnderTest.normalize("ÜüÖöÄäß#'+`´^°!§$%&/()=?-ABCNksdfjiu098723049234lkjdsf"), is("UeueOEoeAEaess__________________ABCNksdfjiu098723049234lkjdsf")); }
### Question: SensorNetworkParser { public Map<String, ComponentType> parseSensorDescriptions(InputStream stream) { Map<String, ComponentType> sensorDescriptions = new HashMap<String, ComponentType>(); ComponentDocument[] components = parseNetworkComponentsFromDescribeSensorResponse(stream); for (ComponentDocument componentDocument : components) { ComponentType networkComponent = componentDocument.getComponent(); if (networkComponent.getIdentificationArray().length > 0) { Identification identification = networkComponent.getIdentificationArray(0); String id = xmlHelper.getUniqueId(identification.getIdentifierList()); if (id != null) { sensorDescriptions.put(id, networkComponent); } } } return sensorDescriptions; } Map<String, ComponentType> parseSensorDescriptions(InputStream stream); }### Answer: @Test public void givenSensorNetwork_parsingNetwork_parsedCorrectNumberOfNetworkMembers() throws XmlException, IOException { XmlObject network = XmlFileLoader.loadXmlFileViaClassloader(SENSOR_NETWORK_SUBSET, getClass()); Map<String, ComponentType> descriptions = new SensorNetworkParser().parseSensorDescriptions(network.newInputStream()); assertThat(descriptions.size(), is(4)); }
### Question: ArcGISSoeEReportingMetadataHandler extends MetadataHandler { protected String parseCategory(String phenomenonLabel) { Pattern pattern = Pattern.compile("\$(.*)\$$"); Matcher matcher = pattern.matcher(parseLastBraceGroup(phenomenonLabel)); return matcher.find() ? matcher.group(1) : phenomenonLabel; } ArcGISSoeEReportingMetadataHandler(SOSMetadata metadata); @Override void assembleTimeseriesMetadata(TimeseriesProperties properties); @Override SOSMetadata performMetadataCompletion(); boolean isCached(String procedure); @Override SOSMetadata updateMetadata(SOSMetadata metadata); }### Answer: @Test public void shouldParseCategoryFromPhenomenonLabelWithSingleBraceGroup() { String category = seam.parseCategory("Cadmium lajsdf (aerosol)"); assertThat(category, is("aerosol")); } @Test public void shouldParseCategoryFromPhenomenonLabelWithMultipleBraceGroup() { String category = seam.parseCategory("Benzo(a)anthracene in PM10 (air+aerosol)"); assertThat(category, is("air+aerosol")); } @Test public void shouldParseWholePhenomenonWhenNoBraceGroupAvailable() { String category = seam.parseCategory("aerosol"); assertThat(category, is("aerosol")); }
### Question: FeatureParser { public Map<Feature, Point> parseFeatures(InputStream stream) { Map<Feature, Point> featureLocations = new HashMap<Feature, Point>(); try { GetFeatureOfInterestResponseDocument responseDoc = GetFeatureOfInterestResponseDocument.Factory.parse(stream); GetFeatureOfInterestResponseType response = responseDoc.getGetFeatureOfInterestResponse(); for (FeaturePropertyType member : response.getFeatureMemberArray()) { PointDocument pointDoc = xmlHelper.getPoint(member, crsUtil); Feature feature = parseFeatureFrom(member); Point location = getCrs84Location(pointDoc); featureLocations.put(feature, location); } } catch (XmlException e) { LOGGER.error("Could not parse GetFeatureOfInterestResponse.", e); } catch (IOException e) { LOGGER.error("Could not read GetFeatureOfInterestResponse.", e); } LOGGER.debug("Parsed #" + featureLocations.size() + " feature locations."); return featureLocations; } FeatureParser(String serviceUrl, CRSUtils crsHelper); Map<Feature, Point> parseFeatures(InputStream stream); }### Answer: @Test public void shouldParseLocations() throws XmlException, IOException { XmlObject featureResponse = loadXmlFileViaClassloader(GET_FOI_RESPONSE, getClass()); Map<Feature, Point> featureLocations = featureParser.parseFeatures(featureResponse.newInputStream()); if (featureLocations == null \|\| featureLocations.isEmpty()) { fail("No features have been parsed!"); } else { assertThat(featureLocations.size(), is(3)); } }
### Question: ArcGISSoeDescribeSensorParser { public String getUomFor(String phenomenonId) { String xPath = "$this String query = String.format(xPath, phenomenonId); Quantity output = xmlHelper.parseFirst(sensorML, query, Quantity.class); return output == null ? null : output.getUom().getCode(); } ArcGISSoeDescribeSensorParser(XmlObject sml); String getUomFor(String phenomenonId); String getShortName(); SensorML getSensorML(); }### Answer: @Test public void shouldParseFirstAvailableUomFromInconsistentMultipleOutputSection() { assertThat("UOM code is not correct!", parser.getUomFor(PHENOMENON), is("mg.m-3")); }
### Question: ArcGISSoeDescribeSensorParser { public String getShortName() { String query = "$this Identifier identifier = xmlHelper.parseFirst(sensorML, query, Identifier.class); return identifier == null ? null : identifier.getTerm().getValue(); } ArcGISSoeDescribeSensorParser(XmlObject sml); String getUomFor(String phenomenonId); String getShortName(); SensorML getSensorML(); }### Answer: @Test public void shouldParseShortName() { assertThat("shortName is incorrect!", parser.getShortName(), is("GB_StationProcess_3746")); }
### Question: SoapSOSRequestBuilder_200 extends SOSRequestBuilder_200_OXFExtension { @Override public String buildGetObservationRequest(ParameterContainer parameters) throws OXFException { parameters.removeParameterShell(parameters.getParameterShellWithCommonName(GET_OBSERVATION_RESPONSE_FORMAT_PARAMETER)); parameters.addParameterShell(GET_OBSERVATION_RESPONSE_FORMAT_PARAMETER, WATERML_20_NS); String request = super.buildGetObservationRequest(parameters); EnvelopeDocument envelope = addSoapEnvelope(request, GET_OBS_SOAP_HEADER_ACTION); return envelope.xmlText(XmlUtil.PRETTYPRINT); } @Override String buildGetCapabilitiesRequest(ParameterContainer parameters); @Override String buildGetFeatureOfInterestRequest(ParameterContainer parameters); @Override String buildDescribeSensorRequest(ParameterContainer parameters); @Override String buildGetObservationRequest(ParameterContainer parameters); String buildGetDataAvailabilityRequest(ParameterContainer parameters); void setUrl(String sosUrl); }### Answer: @Test public void shouldReplaceDefaultOM20ResponseFormatWithWaterML20() throws XmlException, IOException, OXFException { String request = builder.buildGetObservationRequest(parameters); EnvelopeDocument envelope = EnvelopeDocument.Factory.parse(request); GetObservationDocument goDoc = (GetObservationDocument) readBodyNodeFrom(envelope, null); String actual = goDoc.getGetObservation().getResponseFormat(); Assert.assertThat(actual, is("http: }
### Question: TimeseriesParameter implements Serializable { public String getLabel() { return label; } TimeseriesParameter(); TimeseriesParameter(String parameterId, String[] parametersToGenerateId); @JsonIgnore String getGlobalId(); void setLabel(String label); String getLabel(); }### Answer: @Test public void shouldParseLastUrnFragmentAsLabel() { TestParameter testParameter = new TestParameter("urn:123::999:id2134"); assertThat(testParameter.getLabel(), is("id2134")); } @Test public void shouldParseLastHttpPathAsLabel() { TestParameter testParameter = new TestParameter("http: assertThat(testParameter.getLabel(), is("D_GB_Sample.xml")); } @Test public void shouldParseHttpFragmentAsLabel() { TestParameter testParameter = new TestParameter("http: assertThat(testParameter.getLabel(), is("GB_SamplingFeature_281")); }
### Question: TimeseriesParameter implements Serializable { @JsonIgnore public String getGlobalId() { return globalId; } TimeseriesParameter(); TimeseriesParameter(String parameterId, String[] parametersToGenerateId); @JsonIgnore String getGlobalId(); void setLabel(String label); String getLabel(); }### Answer: @Test public void shouldHaveTestSuffixWithinGlobalId() { TestParameter testParameter = new TestParameter("someParameterId"); assertThat(testParameter.getGlobalId(), startsWith("test_")); }
### Question: ResultPage implements Serializable { public boolean isLastPage() { return offset + results.length >= total; } @SuppressWarnings("unused") private ResultPage(); ResultPage(T[] results, int offset, int total); int getOffset(); int getTotal(); T[] getResults(); boolean isLastPage(); }### Answer: @Test public void shouldIndicateThatMorePagesAreAvailable() { ResultPage<String> firstPage = getFirstPage(); assertThat(firstPage.isLastPage(), is(false)); } @Test public void shouldIndicateLastPageWithOverlappingSize() { ResultPage<String> lastPage = getLastPageOverlapping(); assertThat(lastPage.isLastPage(), is(true)); } @Test public void shouldIndicateLastPageWhenMatchingSize() { ResultPage<String> lastPage = getLastPageWithMatchingSize(); assertThat(lastPage.isLastPage(), is(true)); }
### Question: QueryParser { String decodeValue(String value) { value = value.replace("%21", "!"); value = value.replace("%23", "#"); value = value.replace("%24", "$"); value = value.replace("%26", "&"); value = value.replace("%27", "'"); value = value.replace("%28", "("); value = value.replace("%29", ")"); value = value.replace("%2C", ","); value = value.replace("%2F", "/"); value = value.replace("%3A", ":"); value = value.replace("%3B", ";"); value = value.replace("%3D", "="); value = value.replace("%3F", "?"); value = value.replace("%40", "@"); value = value.replace("%5B", "["); value = value.replace("%5D", "]"); value = value.replace("+", " "); value = value.replace("%2B", "+"); value = value.replace("%25", "%"); return value; } QueryParser(String query, boolean compressed); Collection<String> parseServices(); Collection<String> parseVersions(); Collection<String> parseFeatures(); Collection<String> parseOfferings(); Collection<String> parseProcedures(); Collection<String> parsePhenomenons(); TimeRange parseTimeRange(); }### Answer: @Test public void testDecodeQuery() { assertEquals("Unexpected decoded URL.", DECODED_SOS_URL, permalinkParser.decodeValue(ENCODED_SOS_URL)); String decodedCharacters = "! # $ % & ' ( ) * + , / : ; = ? @ [ ]"; String encodedCharacters = "%21+%23+%24+%25+%26+%27+%28+%29+*+%2B+%2C+/+%3A+%3B+%3D+%3F+@+%5B+%5D"; assertEquals("Unexpected decoding.", decodedCharacters, permalinkParser.decodeValue(encodedCharacters)); }
### Question: QueryParser { public Collection<String> parseServices() { String serviceValues = kvps.get(SERVICES.name()); return parseCommaSeparatedValues(serviceValues); } QueryParser(String query, boolean compressed); Collection<String> parseServices(); Collection<String> parseVersions(); Collection<String> parseFeatures(); Collection<String> parseOfferings(); Collection<String> parseProcedures(); Collection<String> parsePhenomenons(); TimeRange parseTimeRange(); }### Answer: @Test public void testParseServiceKvp() { StringBuilder validQuery = new StringBuilder(); validQuery.append("services=").append(ENCODED_SOS_URL); QueryParser parser = new QueryParser(validQuery.toString(), false); Collection<String> parsedServices = parser.parseServices(); assertTrue("Invalid size: " + parsedServices.size(), parsedServices.size() == 1); assertTrue("URL could not be parsed.", parsedServices.contains(DECODED_SOS_URL)); }
### Question: QueryParser { public Collection<String> parseVersions() { String versionValues = kvps.get(VERSIONS.name()); return parseCommaSeparatedValues(versionValues); } QueryParser(String query, boolean compressed); Collection<String> parseServices(); Collection<String> parseVersions(); Collection<String> parseFeatures(); Collection<String> parseOfferings(); Collection<String> parseProcedures(); Collection<String> parsePhenomenons(); TimeRange parseTimeRange(); }### Answer: @Test public void testParseVersionKvp() { StringBuilder validQuery = new StringBuilder(); validQuery.append("versions=").append("2.0.0"); QueryParser parser = new QueryParser(validQuery.toString(), false); Collection<String> parsedVersions = parser.parseVersions(); assertTrue("Invalid size: " + parsedVersions.size(), parsedVersions.size() == 1); assertTrue("Versions could not be parsed.", parsedVersions.contains("2.0.0")); }
### Question: QueryParser { public Collection<String> parseOfferings() { String offeringValues = kvps.get(OFFERINGS.name()); return parseCommaSeparatedValues(offeringValues); } QueryParser(String query, boolean compressed); Collection<String> parseServices(); Collection<String> parseVersions(); Collection<String> parseFeatures(); Collection<String> parseOfferings(); Collection<String> parseProcedures(); Collection<String> parsePhenomenons(); TimeRange parseTimeRange(); }### Answer: @Test public void testParseOfferingKvp() { StringBuilder validQuery = new StringBuilder(); validQuery.append("offerings=").append("WASSERSTAND_ROHDATEN"); QueryParser parser = new QueryParser(validQuery.toString(), false); Collection<String> parsedOfferings = parser.parseOfferings(); assertTrue("Invalid size: " + parsedOfferings.size(), parsedOfferings.size() == 1); assertTrue("Offerings could not be parsed.", parsedOfferings.contains("WASSERSTAND_ROHDATEN")); }
### Question: _1CTokenizer implements Tokenizer { public final void tokenize(SourceCode source, Tokens cpdTokens) { Lexer lexer = _1CLexer.create(new _1CConfiguration(charset)); String fileName = source.getFileName(); List<Token> tokens = lexer.lex(new File(fileName)); for (Token token : tokens) { TokenEntry cpdToken = new TokenEntry(getTokenImage(token), fileName, token.getLine()); cpdTokens.add(cpdToken); } cpdTokens.add(TokenEntry.getEOF()); } _1CTokenizer(Charset charset); final void tokenize(SourceCode source, Tokens cpdTokens); }### Answer: @Test public void test() { _1CTokenizer tokenizer = new _1CTokenizer(Charset.forName("UTF-8")); SourceCode source = mock(SourceCode.class); when(source.getFileName()).thenReturn(new File("src/test/resources/cpd/Person.bsl").getAbsolutePath()); Tokens tokens = new Tokens(); tokenizer.tokenize(source, tokens); assertThat(tokens.getTokens().size()).isGreaterThan(1); assertThat(tokens.getTokens().get(tokens.size() - 1)).isEqualTo(TokenEntry.getEOF()); }
### Question: _1CRuleRepository extends RuleRepository { @Override public List<Rule> createRules() { return annotationRuleParser.parse(CheckList.REPOSITORY_KEY, CheckList.getChecks()); } _1CRuleRepository(AnnotationRuleParser annotationRuleParser); @Override List<Rule> createRules(); }### Answer: @Test public void test() { _1CRuleRepository ruleRepository = new _1CRuleRepository(new AnnotationRuleParser()); assertThat(ruleRepository.getKey()).isEqualTo("1c"); assertThat(ruleRepository.getName()).isEqualTo("Sonar"); List<Rule> rules = ruleRepository.createRules(); assertThat(rules.size()).isEqualTo(CheckList.getChecks().size()); }
### Question: _1CPlugin extends SonarPlugin { public List<Class<? extends Extension>> getExtensions() { return ImmutableList.of( _1C.class, _1CSourceImporter.class, _1CColorizerFormat.class, _1CCpdMapping.class, _1CSquidSensor.class, _1CRuleRepository.class, _1CProfile.class, _1CCommonRulesEngineProvider.class, LCOVSensor.class, _1CTestDriverSensor.class, _1CTestSensor.class); } List<Class<? extends Extension>> getExtensions(); static final String FALSE; static final String FILE_SUFFIXES_KEY; static final String FILE_SUFFIXES_DEFVALUE; static final String PROPERTY_PREFIX; static final String LCOV_REPORT_PATH; static final String LCOV_REPORT_PATH_DEFAULT_VALUE; static final String _1CTESTDRIVER_REPORTS_PATH; static final String _1CTESTDRIVER_REPORTS_PATH_DEFAULT_VALUE; static final String _1CTEST_REPORTS_PATH; static final String _1CTEST_REPORTS_PATH_DEFAULT_VALUE; }### Answer: @Test public void testGetExtensions() throws Exception { assertThat(plugin.getExtensions().size()).isEqualTo(11); }
### Question: _1CProfile extends ProfileDefinition { @Override public RulesProfile createProfile(ValidationMessages validation) { return annotationProfileParser.parse(CheckList.REPOSITORY_KEY, CheckList.SONAR_WAY_PROFILE, _1C.KEY, CheckList.getChecks(), validation); } _1CProfile(AnnotationProfileParser annotationProfileParser); @Override RulesProfile createProfile(ValidationMessages validation); }### Answer: @Test public void should_create_sonar_way_profile() { ValidationMessages validation = ValidationMessages.create(); RuleFinder ruleFinder = ruleFinder(); _1CProfile definition = new _1CProfile(new AnnotationProfileParser(ruleFinder)); RulesProfile profile = definition.createProfile(validation); assertThat(profile.getLanguage()).isEqualTo(_1C.KEY); assertThat(profile.getName()).isEqualTo(RulesProfile.SONAR_WAY_NAME); assertThat(profile.getActiveRulesByRepository(CheckList.REPOSITORY_KEY)) .hasSize(0); assertThat(validation.hasErrors()).isFalse(); }
### Question: _1CSquidSensor implements Sensor { public boolean shouldExecuteOnProject(Project project) { return _1C.KEY.equalsIgnoreCase(project.getLanguageKey()); } _1CSquidSensor(RulesProfile profile, FileLinesContextFactory fileLinesContextFactory); boolean shouldExecuteOnProject(Project project); void analyse(Project project, SensorContext context); @Override String toString(); }### Answer: @Test public void should_execute_on_javascript_project() { Project project = new Project("key"); project.setLanguageKey("java"); assertThat(sensor.shouldExecuteOnProject(project)).isFalse(); project.setLanguageKey("1c"); assertThat(sensor.shouldExecuteOnProject(project)).isTrue(); }
### Question: _1CConfigurationModel extends AbstractConfigurationModel { public List<ConfigurationProperty> getProperties() { return ImmutableList.of(charsetProperty); } List<ConfigurationProperty> getProperties(); @Override Charset getCharset(); @Override Parser<? extends Grammar> doGetParser(); @Override List<Tokenizer> doGetTokenizers(); }### Answer: @Test public void test() { assertThat(model.getTokenizers().size()).isEqualTo(5); assertThat(model.getProperties()).hasSize(1); }
### Question: LCOVParser { public Map<String, CoverageMeasuresBuilder> parseFile(File file) { final List<String> lines; try { lines = FileUtils.readLines(file); } catch (IOException e) { throw new SonarException("Could not read content from file: " + file, e); } return parse(lines); } Map<String, CoverageMeasuresBuilder> parseFile(File file); Map<String, CoverageMeasuresBuilder> parse(List<String> lines); }### Answer: @Test public void unreadable_file() { thrown.expect(SonarException.class); thrown.expectMessage("Could not read content from file: not-found"); parser.parseFile(new File("not-found")); }
### Question: LCOVSensor implements Sensor { public boolean shouldExecuteOnProject(Project project) { return _1C.KEY.equalsIgnoreCase(project.getLanguageKey()) && StringUtils.isNotBlank(_1c.getSettings().getString(_1CPlugin.LCOV_REPORT_PATH)); } LCOVSensor(_1C _1c); boolean shouldExecuteOnProject(Project project); void analyse(Project project, SensorContext context); @Override String toString(); }### Answer: @Test public void test_should_execute() { Project project = mockProject(new Java()); assertThat(sensor.shouldExecuteOnProject(project)).isFalse(); project = mockProject(new _1C(settings)); assertThat(sensor.shouldExecuteOnProject(project)).isTrue(); settings.setProperty(_1CPlugin.LCOV_REPORT_PATH, ""); assertThat(sensor.shouldExecuteOnProject(project)).isFalse(); }
### Question: LCOVSensor implements Sensor { @Override public String toString() { return getClass().getSimpleName(); } LCOVSensor(_1C _1c); boolean shouldExecuteOnProject(Project project); void analyse(Project project, SensorContext context); @Override String toString(); }### Answer: @Test public void test_toString() { assertThat(sensor.toString()).isEqualTo("LCOVSensor"); }
### Question: _1CColorizerFormat extends CodeColorizerFormat { @Override public List<Tokenizer> getTokenizers() { return ImmutableList.of( new StringTokenizer("<span class=\"s\">", "</span>"), new CDocTokenizer("<span class=\"cd\">", "</span>"), new JavadocTokenizer("<span class=\"cppd\">", "</span>"), new CppDocTokenizer("<span class=\"cppd\">", "</span>"), new HtmlCommentTokenizer("<span class=\"cd\">", "</span>"), new KeywordsTokenizer("<span class=\"k\">", "</span>", _1CKeyword.keywordValues())); } _1CColorizerFormat(); @Override List<Tokenizer> getTokenizers(); }### Answer: @Test public void testGetTokenizers() { List<Tokenizer> list = (new _1CColorizerFormat()).getTokenizers(); assertThat(indexOf(list, JavadocTokenizer.class)).isLessThan(indexOf(list, CppDocTokenizer.class)); }
### Question: DockerAccessWithHcClient implements DockerAccess { @Override public void loadImage(String image, File tarArchive) throws DockerAccessException { String url = urlBuilder.loadImage(); try { delegate.post(url, tarArchive, new BodyAndStatusResponseHandler(), HTTP_OK); } catch (IOException e) { throw new DockerAccessException(e, "Unable to load %s", tarArchive); } } DockerAccessWithHcClient(String apiVersion, String baseUrl, String certPath, int maxConnections, KitLogger log); @Override String getServerApiVersion(); @Override void buildImage(String image, File dockerArchive, BuildOptions options); @Override boolean hasImage(String name); @Override String getImageId(String name); @Override void loadImage(String image, File tarArchive); @Override void pullImage(String image, String authHeader, String registry); @Override void pushImage(String image, String authHeader, String registry, int retries); @Override void saveImage(String image, String filename); @Override void tag(String sourceImage, String targetImage, boolean force); @Override boolean removeImage(String image, boolean... forceOpt); }### Answer: @Test public void testLoadImage() { givenAnImageName("test"); givenArchiveFile("test.tar"); whenLoadImage(); thenNoException(); }
### Question: EcrExtendedAuth { public RegistryAuth extendedAuth(RegistryAuth localCredentials) throws IOException { JsonObject jo = getAuthorizationToken(localCredentials); JsonArray authorizationDatas = jo.getAsJsonArray("authorizationData"); JsonObject authorizationData = authorizationDatas.get(0).getAsJsonObject(); String authorizationToken = authorizationData.get("authorizationToken").getAsString(); return new RegistryAuth.Builder().withCredentialsEncoded(authorizationToken).email("none").build(); } EcrExtendedAuth(KitLogger logger, String registry); boolean isAwsRegistry(); RegistryAuth extendedAuth(RegistryAuth localCredentials); }### Answer: @Test public void testClientClosedAndCredentialsDecoded(@Mocked final CloseableHttpClient closeableHttpClient, @Mocked final CloseableHttpResponse closeableHttpResponse, @Mocked final StatusLine statusLine) throws IOException { final HttpEntity entity = new StringEntity("{\"authorizationData\": [{" + "\"authorizationToken\": \"QVdTOnBhc3N3b3Jk\"," + "\"expiresAt\": 1448878779.809," + "\"proxyEndpoint\": \"https: new Expectations() {{ statusLine.getStatusCode(); result = 200; closeableHttpResponse.getEntity(); result = entity; }}; EcrExtendedAuth eea = new EcrExtendedAuth(logger, "123456789012.dkr.ecr.eu-west-1.amazonaws.com") { CloseableHttpClient createClient() { return closeableHttpClient; } }; RegistryAuth localCredentials = new RegistryAuth.Builder() .username("username") .password("password") .build(); RegistryAuth awsCredentials = eea.extendedAuth(localCredentials); assertEquals("AWS", awsCredentials.getUsername()); assertEquals("password", awsCredentials.getPassword()); new Verifications() {{ closeableHttpClient.close(); }}; }
### Question: FromConfigRegistryAuthHandler implements RegistryAuthHandler { @Override public RegistryAuth create(RegistryAuthConfig.Kind kind, String user, String registry, Function<String, String> decryptor) { if (registryAuthConfig.getUsername(kind) != null) { if (registryAuthConfig.getPassword(kind) == null) { throw new IllegalArgumentException("No 'password' given while using <authConfig> in configuration for mode " + kind); } log.debug("AuthConfig: credentials from plugin config"); return RegistryAuth.fromRegistryAuthConfig(registryAuthConfig, kind, decryptor); } return null; } FromConfigRegistryAuthHandler(RegistryAuthConfig registryAuthConfig, KitLogger log); @Override String getId(); @Override RegistryAuth create(RegistryAuthConfig.Kind kind, String user, String registry, Function<String, String> decryptor); }### Answer: @Test public void testFromPluginConfiguration() throws IOException { FromConfigRegistryAuthHandler handler = new FromConfigRegistryAuthHandler(setupAuthConfigFactoryWithConfigData(), log); RegistryAuth config = handler.create(RegistryAuthConfig.Kind.PUSH, null, null, s -> s); verifyAuthConfig(config, "roland", "secret", "[email protected]"); } @Test public void testFromPluginConfigurationPull() throws IOException { FromConfigRegistryAuthHandler handler = new FromConfigRegistryAuthHandler(setupAuthConfigFactoryWithConfigDataForKind(RegistryAuthConfig.Kind.PULL), log); RegistryAuth config = handler.create(RegistryAuthConfig.Kind.PULL, null, null, s -> s); verifyAuthConfig(config, "roland", "secret", "[email protected]"); } @Test public void testFromPluginConfigurationFailed() throws IOException { FromConfigRegistryAuthHandler handler = new FromConfigRegistryAuthHandler( new RegistryAuthConfig.Builder().addDefaultConfig(RegistryAuth.USERNAME, "admin").build(), log); expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage(containsString("password")); handler.create(RegistryAuthConfig.Kind.PUSH, null, null, s -> s); }
### Question: DockerAccessWithHcClient implements DockerAccess { @Override public void saveImage(String image, String filename) throws DockerAccessException { ImageName name = new ImageName(image); String url = urlBuilder.getImage(name); try { delegate.get(url, getImageResponseHandler(filename), HTTP_OK); } catch (IOException e) { throw new DockerAccessException(e, "Unable to save '%s' to '%s'", image, filename); } } DockerAccessWithHcClient(String apiVersion, String baseUrl, String certPath, int maxConnections, KitLogger log); @Override String getServerApiVersion(); @Override void buildImage(String image, File dockerArchive, BuildOptions options); @Override boolean hasImage(String name); @Override String getImageId(String name); @Override void loadImage(String image, File tarArchive); @Override void pullImage(String image, String authHeader, String registry); @Override void pushImage(String image, String authHeader, String registry, int retries); @Override void saveImage(String image, String filename); @Override void tag(String sourceImage, String targetImage, boolean force); @Override boolean removeImage(String image, boolean... forceOpt); }### Answer: @Test public void testSaveImage() throws IOException { givenAnImageName("test"); givenFilename("test.tar"); givenCompression(ArchiveCompression.none); whenSaveImage(); thenNoException(); }
### Question: DockerFileBuilder { public DockerFileBuilder maintainer(String maintainer) { this.maintainer = maintainer; return this; } DockerFileBuilder(); File write(File destDir); String content(); DockerFileBuilder baseImage(String baseImage); DockerFileBuilder maintainer(String maintainer); DockerFileBuilder workdir(String workdir); DockerFileBuilder basedir(String dir); DockerFileBuilder cmd(Arguments cmd); DockerFileBuilder entryPoint(Arguments entryPoint); DockerFileBuilder assemblyUser(String assemblyUser); DockerFileBuilder user(String user); DockerFileBuilder healthCheck(HealthCheckConfiguration healthCheck); DockerFileBuilder add(String source, String destination); DockerFileBuilder expose(List<String> ports); DockerFileBuilder run(List<String> runCmds); DockerFileBuilder exportTargetDir(Boolean exportTargetDir); DockerFileBuilder env(Map<String, String> values); DockerFileBuilder labels(Map<String,String> values); DockerFileBuilder volumes(List<String> volumes); DockerFileBuilder optimise(); static List<String[]> extractLines(File dockerFile, String keyword, Function<String, String> interpolator); }### Answer: @Test public void testMaintainer() { String dockerfileContent = new DockerFileBuilder().maintainer("[email protected]").content(); assertThat(dockerfileToMap(dockerfileContent), hasEntry("MAINTAINER", "[email protected]")); }
### Question: DockerFileBuilder { public DockerFileBuilder optimise() { this.shouldOptimise = true; return this; } DockerFileBuilder(); File write(File destDir); String content(); DockerFileBuilder baseImage(String baseImage); DockerFileBuilder maintainer(String maintainer); DockerFileBuilder workdir(String workdir); DockerFileBuilder basedir(String dir); DockerFileBuilder cmd(Arguments cmd); DockerFileBuilder entryPoint(Arguments entryPoint); DockerFileBuilder assemblyUser(String assemblyUser); DockerFileBuilder user(String user); DockerFileBuilder healthCheck(HealthCheckConfiguration healthCheck); DockerFileBuilder add(String source, String destination); DockerFileBuilder expose(List<String> ports); DockerFileBuilder run(List<String> runCmds); DockerFileBuilder exportTargetDir(Boolean exportTargetDir); DockerFileBuilder env(Map<String, String> values); DockerFileBuilder labels(Map<String,String> values); DockerFileBuilder volumes(List<String> volumes); DockerFileBuilder optimise(); static List<String[]> extractLines(File dockerFile, String keyword, Function<String, String> interpolator); }### Answer: @Test public void testOptimise() { String dockerfileContent = new DockerFileBuilder().optimise().run(Arrays.asList("echo something", "echo two")).content(); assertThat(dockerfileToMap(dockerfileContent), hasEntry("RUN", "echo something && echo two")); }
### Question: DockerFileBuilder { public DockerFileBuilder user(String user) { this.user = user; return this; } DockerFileBuilder(); File write(File destDir); String content(); DockerFileBuilder baseImage(String baseImage); DockerFileBuilder maintainer(String maintainer); DockerFileBuilder workdir(String workdir); DockerFileBuilder basedir(String dir); DockerFileBuilder cmd(Arguments cmd); DockerFileBuilder entryPoint(Arguments entryPoint); DockerFileBuilder assemblyUser(String assemblyUser); DockerFileBuilder user(String user); DockerFileBuilder healthCheck(HealthCheckConfiguration healthCheck); DockerFileBuilder add(String source, String destination); DockerFileBuilder expose(List<String> ports); DockerFileBuilder run(List<String> runCmds); DockerFileBuilder exportTargetDir(Boolean exportTargetDir); DockerFileBuilder env(Map<String, String> values); DockerFileBuilder labels(Map<String,String> values); DockerFileBuilder volumes(List<String> volumes); DockerFileBuilder optimise(); static List<String[]> extractLines(File dockerFile, String keyword, Function<String, String> interpolator); }### Answer: @Test public void testUser() { String dockerFile = new DockerFileBuilder().assemblyUser("jboss:jboss:jboss").user("bob") .add("a","a/nested").add("b","b/deeper/nested").content(); String EXPECTED_REGEXP = "USER bob$"; Pattern pattern = Pattern.compile(EXPECTED_REGEXP); assertTrue(pattern.matcher(dockerFile).find()); }
### Question: BuildConfiguration implements Serializable { public String validate() throws IllegalArgumentException { if (entryPoint != null) { entryPoint.validate(); } if (cmd != null) { cmd.validate(); } if (healthCheck != null) { healthCheck.validate(); } if ((dockerFile != null \|\| contextDir != null) && dockerArchive != null) { throw new IllegalArgumentException("Both <dockerFile> (<dockerFileDir>) and <dockerArchive> are set. " + "Only one of them can be specified."); } if (healthCheck != null) { return "1.24"; } else if (args != null) { return "1.21"; } else { return null; } } BuildConfiguration(); boolean isDockerFileMode(); String getDockerFile(); String getDockerArchive(); String getContextDir(); String getFilter(); String getFrom(); Map<String, String> getFromExt(); String getRegistry(); String getMaintainer(); String getWorkdir(); AssemblyConfiguration getAssemblyConfiguration(); List<String> getPorts(); String getImagePullPolicy(); List<String> getVolumes(); List<String> getTags(); Map<String, String> getEnv(); Map<String, String> getLabels(); Arguments getCmd(); String getCleanupMode(); Boolean getNoCache(); Boolean getOptimise(); Boolean getSkip(); ArchiveCompression getCompression(); Map<String, String> getBuildOptions(); Arguments getEntryPoint(); List<String> getRunCmds(); String getUser(); HealthCheckConfiguration getHealthCheck(); Map<String, String> getArgs(); String validate(); File calculateDockerFilePath(); }### Answer: @Test public void dockerFileAndArchive() { BuildConfiguration config = new BuildConfiguration.Builder(). dockerArchive("this"). dockerFile("that").build(); try { config.validate(); } catch (IllegalArgumentException expected) { return; } fail("Should have failed."); }
### Question: BuildConfiguration implements Serializable { public ArchiveCompression getCompression() { return compression; } BuildConfiguration(); boolean isDockerFileMode(); String getDockerFile(); String getDockerArchive(); String getContextDir(); String getFilter(); String getFrom(); Map<String, String> getFromExt(); String getRegistry(); String getMaintainer(); String getWorkdir(); AssemblyConfiguration getAssemblyConfiguration(); List<String> getPorts(); String getImagePullPolicy(); List<String> getVolumes(); List<String> getTags(); Map<String, String> getEnv(); Map<String, String> getLabels(); Arguments getCmd(); String getCleanupMode(); Boolean getNoCache(); Boolean getOptimise(); Boolean getSkip(); ArchiveCompression getCompression(); Map<String, String> getBuildOptions(); Arguments getEntryPoint(); List<String> getRunCmds(); String getUser(); HealthCheckConfiguration getHealthCheck(); Map<String, String> getArgs(); String validate(); File calculateDockerFilePath(); }### Answer: @Test public void compression() { BuildConfiguration config = new BuildConfiguration.Builder(). compression("gzip").build(); assertEquals(gzip, config.getCompression()); config = new BuildConfiguration.Builder().build(); assertEquals(none, config.getCompression()); config = new BuildConfiguration.Builder(). compression("bzip2").build(); assertEquals(bzip2, config.getCompression()); try { new BuildConfiguration.Builder(). compression("bzip").build(); fail(); } catch (Exception exp) { assertTrue(exp.getMessage().contains("bzip")); } }
### Question: EnricherFactory { List<Enricher<P>> createEnrichers(String... descriptorPaths) { try { EnricherEntry.initDefaultOrder(); TreeMap<EnricherEntry,Enricher<P>> enricherMap = new TreeMap<>(); for (String descriptor : descriptorPaths) { readEnricherDefinitions(enricherMap, descriptor); } ArrayList<Enricher<P>> ret = new ArrayList<>(); ret.addAll(enricherMap.values()); return ret; } finally { EnricherEntry.removeDefaultOrder(); } } EnricherFactory(ClassLoader... additionalClassLoaders); }### Answer: @Test public void testOrder() { List<Enricher<ProjectContext>> enrichers = enricherFactory.createEnrichers("enricher/test-enrichers-default", "enricher/test-enrichers"); String[] orderExpected = new String[] { "three", "two", "five", "one"}; assertEquals(enrichers.size(), 4); Iterator<Enricher<ProjectContext>> it = enrichers.iterator(); for (String val : orderExpected) { assertEquals(it.next().getName(),val); } } @Test public void errorHandling() { try { enricherFactory.createEnrichers("enricher/error-enrichers"); fail(); } catch (IllegalStateException exp) { assertTrue(exp.getMessage().matches(".bla\\.blub\\.NotExist.")); } }
### Question: KeyStoreUtil { public static KeyStore createDockerKeyStore(String certPath) throws IOException, GeneralSecurityException { PrivateKey privKey = loadPrivateKey(certPath + "/key.pem"); Certificate[] certs = loadCertificates(certPath + "/cert.pem"); KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType()); keyStore.load(null); keyStore.setKeyEntry("docker", privKey, "docker".toCharArray(), certs); addCA(keyStore, certPath + "/ca.pem"); return keyStore; } static KeyStore createDockerKeyStore(String certPath); }### Answer: @Test public void createKeyStore() throws Exception { KeyStore keyStore = KeyStoreUtil.createDockerKeyStore(getFile("certpath")); KeyStore.PrivateKeyEntry pkEntry = (KeyStore.PrivateKeyEntry) keyStore.getEntry("docker", new KeyStore.PasswordProtection("docker".toCharArray())); assertNotNull(pkEntry); assertNotNull(pkEntry.getCertificate()); assertNotNull(keyStore.getCertificate("cn=ca-test,o=internet widgits pty ltd,st=some-state,c=cr")); assertNotNull(keyStore.getCertificate("cn=ca-test-2,o=internet widgits pty ltd,st=some-state,c=cr")); }
### Question: KeyStoreUtil { static PrivateKey loadPrivateKey(String keyPath) throws IOException, GeneralSecurityException { try (Reader reader = new FileReader(keyPath); PEMParser parser = new PEMParser(reader)) { Object readObject; while ((readObject = parser.readObject()) != null) { if (readObject instanceof PEMKeyPair) { PEMKeyPair keyPair = (PEMKeyPair) readObject; return generatePrivateKey(keyPair.getPrivateKeyInfo()); } else if (readObject instanceof PrivateKeyInfo) { return generatePrivateKey((PrivateKeyInfo) readObject); } } } throw new GeneralSecurityException("Cannot generate private key from file: " + keyPath); } static KeyStore createDockerKeyStore(String certPath); }### Answer: @Test public void loadPrivateKeyDefault() throws Exception { PrivateKey privateKey = KeyStoreUtil.loadPrivateKey(getFile("keys/pkcs1.pem")); assertNotNull(privateKey); } @Test public void loadPrivateKeyPKCS8() throws Exception { PrivateKey privateKey = KeyStoreUtil.loadPrivateKey(getFile("keys/pkcs8.pem")); assertNotNull(privateKey); } @Test public void loadPrivateKeyECDSA() throws Exception { PrivateKey privateKey = KeyStoreUtil.loadPrivateKey(getFile("keys/ecdsa.pem")); assertNotNull(privateKey); } @Test public void loadInvalidPrivateKey() throws Exception { exception.expect(GeneralSecurityException.class); exception.expectMessage("Cannot generate private key"); KeyStoreUtil.loadPrivateKey(getFile("keys/invalid.pem")); }
### Question: EcrExtendedAuth { public boolean isAwsRegistry() { return isAwsRegistry; } EcrExtendedAuth(KitLogger logger, String registry); boolean isAwsRegistry(); RegistryAuth extendedAuth(RegistryAuth localCredentials); }### Answer: @Test public void testIsNotAws() { assertFalse(new EcrExtendedAuth(logger, "jolokia").isAwsRegistry()); } @Test public void testIsAws() { assertTrue(new EcrExtendedAuth(logger, "123456789012.dkr.ecr.eu-west-1.amazonaws.com").isAwsRegistry()); }
### Question: ObjModel extends IndexedModel { protected static void parseInts(String str, int[] ints) { int len = str.length(); int intIndex = 0; int currentInt = -1; ints[0] = -1; ints[1] = -1; ints[2] = -1; for (int i = 0; i < len; i++) { char c = str.charAt(i); if (c >= '0' && c <= '9') { if (currentInt == -1) { currentInt = (c - '0'); } else { currentInt *= 10; currentInt += (c - '0'); } } else { if (currentInt >= 0) { ints[intIndex++] = currentInt; currentInt = -1; } else { ints[intIndex++] = -1; } } } if (currentInt >= 0) { ints[intIndex] = currentInt; } } ObjModel(@NonNull InputStream inputStream); @Override void initModelMatrix(float boundSize); }### Answer: @Test public void testParseInts() throws Exception { int[] ints = new int[4]; ObjModel.parseInts("1/2/3", ints); assertEquals(ints[0], 1); assertEquals(ints[1], 2); assertEquals(ints[2], 3); ObjModel.parseInts("111/222/333/444", ints); assertEquals(ints[0], 111); assertEquals(ints[1], 222); assertEquals(ints[2], 333); assertEquals(ints[3], 444); ObjModel.parseInts("12 assertEquals(ints[0], 12); assertEquals(ints[1], -1); assertEquals(ints[2], 34); ObjModel.parseInts("42", ints); assertEquals(ints[0], 42); assertEquals(ints[1], -1); assertEquals(ints[2], -1); }
### Question: SignatureConfig { public void write(Writer out) throws IOException { Ini configIni = new Ini(); Section section = configIni.add(SECTION_NAME); section.put("algorithm", algorithm.toString()); section.put("provider", provider); section.put("destination", destination.toString()); if (destinationTable != null) { section.put("table", destinationTable); } if (defaultVisibility != null) { section.put("defaultVisibility", new String(defaultVisibility, VISIBILITY_CHARSET)); } configIni.store(out); } SignatureConfig(ValueSigner signer, String provider, Destination destination, String destinationTable, byte[] defaultVisibility); void write(Writer out); boolean isSignatureInSeparateTable(); ValueSigner getAlgorithm(); }### Answer: @Test public void writeTest() throws Exception { File file = writeConfigToFile(config1); Ini expectedIni = getIni("config1.ini"); Ini actualIni = new Ini(file); assertThat("writing the ini file produces the correct configuration", expectedIni, equalTo(actualIni)); file = writeConfigToFile(config2); expectedIni = getIni("config2.ini"); actualIni = new Ini(file); assertThat("writing the ini file produces the correct configuration", expectedIni, equalTo(actualIni)); file = writeConfigToFile(config3); expectedIni = getIni("config3.ini"); actualIni = new Ini(file); assertThat("writing the ini file produces the correct configuration", expectedIni, equalTo(actualIni)); }
### Question: SignedBatchWriter implements BatchWriter { @Override public void addMutations(Iterable<Mutation> iterable) throws MutationsRejectedException { for (Mutation mutation : iterable) { addMutation(mutation); } } SignedBatchWriter(Connector connector, String tableName, BatchWriterConfig batchConfig, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override void addMutation(Mutation mutation); @Override void addMutations(Iterable<Mutation> iterable); @Override void flush(); @Override void close(); }### Answer: @Test public void addMutationsTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); BatchWriter writer = new SignedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)); List<Mutation> mutations = new ArrayList<>(); Mutation mutation = new Mutation("row"); mutation.put("colF", "colQ", "val"); mutations.add(mutation); writer.addMutations(mutations); verify(mockWriter, times(1)).addMutation(any()); verify(mockSignatureWriter, never()).addMutation(any()); mutations.add(mutation); writer.addMutations(mutations); verify(mockWriter, times(3)).addMutation(any()); verify(mockSignatureWriter, never()).addMutation(any()); mutations.add(mutation); writer.addMutations(mutations); verify(mockWriter, times(6)).addMutation(any()); verify(mockSignatureWriter, never()).addMutation(any()); }
### Question: SignedBatchWriter implements BatchWriter { @Override public void flush() throws MutationsRejectedException { tableWriter.flush(); if (signatureTableWriter != null) { signatureTableWriter.flush(); } } SignedBatchWriter(Connector connector, String tableName, BatchWriterConfig batchConfig, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override void addMutation(Mutation mutation); @Override void addMutations(Iterable<Mutation> iterable); @Override void flush(); @Override void close(); }### Answer: @Test public void flushTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); new SignedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).flush(); verify(mockWriter).flush(); } @Test public void flushExternalTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); when(mockConnector.createBatchWriter(SIG_TABLE, null)).thenReturn(mockSignatureWriter); new SignedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.ECDSA)).flush(); verify(mockWriter).flush(); verify(mockSignatureWriter).flush(); }
### Question: SignedBatchWriter implements BatchWriter { @Override public void close() throws MutationsRejectedException { tableWriter.close(); if (signatureTableWriter != null) { signatureTableWriter.close(); } } SignedBatchWriter(Connector connector, String tableName, BatchWriterConfig batchConfig, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override void addMutation(Mutation mutation); @Override void addMutations(Iterable<Mutation> iterable); @Override void flush(); @Override void close(); }### Answer: @Test public void closeTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); new SignedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).close(); verify(mockWriter).close(); } @Test public void closeExternalTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); when(mockConnector.createBatchWriter(SIG_TABLE, null)).thenReturn(mockSignatureWriter); new SignedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.ECDSA)).close(); verify(mockWriter).close(); verify(mockSignatureWriter).close(); }
### Question: EncryptedBatchScanner implements BatchScanner { @Override public void fetchColumnFamily(Text col) { checkArgument(col != null, "col is null"); ColumnFilterResult search = encryptor.getColumnFamilyFilter(col); for (Column filter : search.serverSideFilters) { scanner.fetchColumnFamily(new Text(filter.getColumnFamily())); } if (search.needsClientSideFiltering) { clientSideColumnFilters.add(new Column(TextUtil.getBytes(col), null, null)); } } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig, EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); }### Answer: @Test public void fetchColumnFamilyException() throws Exception { BatchScanner scanner = new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-key.ini"), KEYS); try { scanner.fetchColumnFamily(null); fail("null column family not allowed"); } catch (IllegalArgumentException e) { } }
### Question: EncryptedBatchScanner implements BatchScanner { @Override public void clearScanIterators() { scanner.clearScanIterators(); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig, EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); }### Answer: @Test public void clearScanIteratorsTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).clearScanIterators(); verify(mockScanner).clearScanIterators(); }
### Question: EncryptedBatchScanner implements BatchScanner { @Override public void close() { scanner.close(); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig, EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); }### Answer: @Test public void closeTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).close(); verify(mockScanner).close(); }
### Question: EncryptedBatchScanner implements BatchScanner { @Override public Authorizations getAuthorizations() { return scanner.getAuthorizations(); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig, EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); }### Answer: @Test public void getAuthorizationsTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); when(mockScanner.getAuthorizations()).thenReturn(authorizations); Authorizations auths = new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).getAuthorizations(); verify(mockScanner).getAuthorizations(); assertThat("correct authorizations returned", auths, equalTo(authorizations)); }

Subsets and Splits

No saved queries yet

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