Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
Utils { public static String dropTrailingSeparator(String urlParameterTokens, String paramSeparator) { return StringUtils.substringBeforeLast(urlParameterTokens, paramSeparator); } private Utils(); static String dropTrailingSeparator(String urlParameterTokens, String paramSeparator); static String urlEncode(String token); static boolean isAValidJSONText(String resultAsString); static String readPropertyFrom(String propertyFilename, String propertyName); static String dropStartAndEndDelimiters(String inputString); static final String OPENING_BOX_BRACKET; static final String CLOSING_BOX_BRACKET; }
@Test public void should_Remove_Trailing_Separator_From_String_When_A_Single_Separator_Is_Passed_In() { assertThat(dropTrailingSeparator("http: }
Utils { public static String dropStartAndEndDelimiters(String inputString) { String result = inputString; if (result.startsWith(OPENING_BOX_BRACKET)) { if (result.length() == 1) { result = ""; } else { result = result.substring(1, result.length()); } } if (result.endsWith(CLOSING_BOX_BRACKET)) { result = result.substring(0, result.length() - 1); } return result; } private Utils(); static String dropTrailingSeparator(String urlParameterTokens, String paramSeparator); static String urlEncode(String token); static boolean isAValidJSONText(String resultAsString); static String readPropertyFrom(String propertyFilename, String propertyName); static String dropStartAndEndDelimiters(String inputString); static final String OPENING_BOX_BRACKET; static final String CLOSING_BOX_BRACKET; }
@Test public void should_Drop_Begin_And_End_Delimiters_In_An_Empty_String() { String inputString = "[]"; String actualString = dropStartAndEndDelimiters(inputString); String expectedString = ""; assertThat("Begin & End delimiters haven't been dropped", actualString, is(expectedString)); } @Test public void should_Drop_Double_Begin_And_End_Delimiters_In_An_Empty_String() { String inputString = "[[]]"; String actualString = dropStartAndEndDelimiters(inputString); actualString = dropStartAndEndDelimiters(actualString); String expectedString = ""; assertThat("Begin & End delimiters haven't been dropped", actualString, is(expectedString)); } @Test public void should_Drop_Begin_And_End_Delimiters_In_A_Simple_String() { String inputString = "[{'some': 'value'}]"; String actualString = dropStartAndEndDelimiters(inputString); String expectedString = "{'some': 'value'}"; assertThat("Begin & End delimiters haven't been dropped", actualString, is(expectedString)); } @Test public void should_Drop_Double_Begin_And_End_Delimiters_In_A_Simple_String() { String inputString = "[[{'some': 'value'}]]"; String actualString = dropStartAndEndDelimiters(inputString); actualString = dropStartAndEndDelimiters(actualString); String expectedString = "{'some': 'value'}"; assertThat("Begin & End delimiters haven't been dropped", actualString, is(expectedString)); }
TracingChannelInterceptor extends ChannelInterceptorAdapter implements ExecutorChannelInterceptor { private Message<?> preSendServerSpan(Message<?> message) { Span span = tracer.buildSpan((String) message.getHeaders() .getOrDefault(SIMP_DESTINATION, UNKNOWN_DESTINATION)) .asChildOf(tracer .extract(Format.Builtin.TEXT_MAP, new TextMapExtractAdapter(message.getHeaders()))) .withTag(Tags.SPAN_KIND.getKey(), spanKind) .withTag(Tags.COMPONENT.getKey(), WEBSOCKET) .start(); return MessageBuilder.fromMessage(message) .setHeader(OPENTRACING_SPAN, span) .build(); } TracingChannelInterceptor(Tracer tracer, String spanKind); @Override Message<?> preSend(Message<?> message, MessageChannel channel); @Override void afterMessageHandled(Message<?> message, MessageChannel channel, MessageHandler handler, Exception arg3); @Override Message<?> beforeHandle(Message<?> message, MessageChannel channel, MessageHandler handler); }
@Test public void testPreSendServerSpan() { MessageBuilder<String> messageBuilder = MessageBuilder.withPayload("Hi") .setHeader(TracingChannelInterceptor.SIMP_MESSAGE_TYPE, SimpMessageType.MESSAGE) .setHeader(TracingChannelInterceptor.SIMP_DESTINATION, TEST_DESTINATION); MockSpan parentSpan = mockTracer.buildSpan("parent").start(); mockTracer.inject(parentSpan.context(), Format.Builtin.TEXT_MAP, new TextMapInjectAdapter(messageBuilder)); TracingChannelInterceptor interceptor = new TracingChannelInterceptor(mockTracer, Tags.SPAN_KIND_SERVER); Message<?> processed = interceptor.preSend(messageBuilder.build(), null); assertTrue(processed.getHeaders().containsKey(TracingChannelInterceptor.OPENTRACING_SPAN)); MockSpan childSpan = (MockSpan) processed.getHeaders() .get(TracingChannelInterceptor.OPENTRACING_SPAN); assertEquals(parentSpan.context().spanId(), childSpan.parentId()); assertEquals(parentSpan.context().traceId(), childSpan.context().traceId()); assertEquals(TEST_DESTINATION, childSpan.operationName()); assertEquals(Tags.SPAN_KIND_SERVER, childSpan.tags().get(Tags.SPAN_KIND.getKey())); assertEquals(TracingChannelInterceptor.WEBSOCKET, childSpan.tags().get(Tags.COMPONENT.getKey())); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public int getActiveCount() { return delegate.getActiveCount(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void getActiveCount() { scheduler.getActiveCount(); verify(delegate).getActiveCount(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void execute(Runnable task) { delegate.execute(new TracedRunnable(task, tracer)); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void execute() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); scheduler.execute(mockRunnable); verify(delegate).execute(argumentCaptor.capture()); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); } @Test public void executeWithTimeout() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); scheduler.execute(mockRunnable, 1000L); verify(delegate).execute(argumentCaptor.capture(), eq(1000L)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public Future<?> submit(Runnable task) { return delegate.submit(new TracedRunnable(task, tracer)); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void submitRunnable() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); scheduler.submit(mockRunnable); verify(delegate).submit(argumentCaptor.capture()); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); } @Test public void submitCallable() { final ArgumentCaptor<TracedCallable> argumentCaptor = ArgumentCaptor.forClass(TracedCallable.class); scheduler.submit(mockCallable); verify(delegate).submit(argumentCaptor.capture()); verifyTracedCallable(argumentCaptor.getValue(), mockCallable, mockTracer); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ListenableFuture<?> submitListenable(Runnable task) { return delegate.submitListenable(new TracedRunnable(task, tracer)); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void submitListenableRunnable() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); scheduler.submitListenable(mockRunnable); verify(delegate).submitListenable(argumentCaptor.capture()); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); } @Test public void submitListenableCallable() { final ArgumentCaptor<TracedCallable> argumentCaptor = ArgumentCaptor.forClass(TracedCallable.class); scheduler.submitListenable(mockCallable); verify(delegate).submitListenable(argumentCaptor.capture()); verifyTracedCallable(argumentCaptor.getValue(), mockCallable, mockTracer); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override @Nullable public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) { return delegate.schedule(new TracedRunnable(task, tracer), trigger); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void scheduleWithTrigger() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); final Trigger trigger = mock(Trigger.class); scheduler.schedule(mockRunnable, trigger); verify(delegate).schedule(argumentCaptor.capture(), eq(trigger)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); } @Test public void scheduleWithDate() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); final Date date = mock(Date.class); scheduler.schedule(mockRunnable, date); verify(delegate).schedule(argumentCaptor.capture(), eq(date)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); } @Test public void scheduleWithInstant() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); final Instant instant = Instant.now(); scheduler.schedule(mockRunnable, instant); verify(delegate).schedule(argumentCaptor.capture(), eq(instant)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); }
TracingChannelInterceptor extends ChannelInterceptorAdapter implements ExecutorChannelInterceptor { private Message<?> preSendClientSpan(Message<?> message) { Span span = tracer.buildSpan((String) message.getHeaders() .getOrDefault(SIMP_DESTINATION, UNKNOWN_DESTINATION)) .withTag(Tags.SPAN_KIND.getKey(), spanKind) .withTag(Tags.COMPONENT.getKey(), WEBSOCKET) .start(); MessageBuilder<?> messageBuilder = MessageBuilder.fromMessage(message) .setHeader(OPENTRACING_SPAN, span); tracer .inject(span.context(), Format.Builtin.TEXT_MAP, new TextMapInjectAdapter(messageBuilder)); return messageBuilder.build(); } TracingChannelInterceptor(Tracer tracer, String spanKind); @Override Message<?> preSend(Message<?> message, MessageChannel channel); @Override void afterMessageHandled(Message<?> message, MessageChannel channel, MessageHandler handler, Exception arg3); @Override Message<?> beforeHandle(Message<?> message, MessageChannel channel, MessageHandler handler); }
@Test public void testPreSendClientSpan() { MessageBuilder<String> messageBuilder = MessageBuilder.withPayload("Hi") .setHeader(TracingChannelInterceptor.SIMP_MESSAGE_TYPE, SimpMessageType.MESSAGE) .setHeader(TracingChannelInterceptor.SIMP_DESTINATION, TEST_DESTINATION); MockSpan parentSpan = mockTracer.buildSpan("parent").start(); TracingChannelInterceptor interceptor = new TracingChannelInterceptor(mockTracer, Tags.SPAN_KIND_CLIENT); Scope parentScope = mockTracer.scopeManager().activate(parentSpan); Message<?> processed = interceptor.preSend(messageBuilder.build(), null); parentScope.close(); parentSpan.finish(); assertTrue(processed.getHeaders().containsKey(TracingChannelInterceptor.OPENTRACING_SPAN)); MockSpan childSpan = (MockSpan) processed.getHeaders() .get(TracingChannelInterceptor.OPENTRACING_SPAN); assertEquals(parentSpan.context().spanId(), childSpan.parentId()); assertEquals(parentSpan.context().traceId(), childSpan.context().traceId()); MockSpan.MockContext context = (MockSpan.MockContext) mockTracer .extract(Format.Builtin.TEXT_MAP, new TextMapExtractAdapter(processed.getHeaders())); assertEquals(childSpan.context().traceId(), context.traceId()); assertEquals(childSpan.context().spanId(), context.spanId()); assertEquals(TEST_DESTINATION, childSpan.operationName()); assertEquals(Tags.SPAN_KIND_CLIENT, childSpan.tags().get(Tags.SPAN_KIND.getKey())); assertEquals(TracingChannelInterceptor.WEBSOCKET, childSpan.tags().get(Tags.COMPONENT.getKey())); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period) { return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), startTime, period); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void scheduleAtFixedRateWithDateAndLong() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); final Date date = new Date(); scheduler.scheduleAtFixedRate(mockRunnable, date, 1000L); verify(delegate).scheduleAtFixedRate(argumentCaptor.capture(), eq(date), eq(1000L)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); } @Test public void scheduleAtFixedRateWithInstantAndDuration() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); final Instant instant = Instant.now(); final Duration duration = Duration.ofMinutes(1); scheduler.scheduleAtFixedRate(mockRunnable, instant, duration); verify(delegate).scheduleAtFixedRate(argumentCaptor.capture(), eq(instant), eq(duration)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); } @Test public void scheduleAtFixedRateWithLong() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); scheduler.scheduleAtFixedRate(mockRunnable, 1000L); verify(delegate).scheduleAtFixedRate(argumentCaptor.capture(), eq(1000L)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); } @Test public void scheduleAtFixedRateWithDuration() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); final Duration duration = Duration.ofMinutes(5); scheduler.scheduleAtFixedRate(mockRunnable, duration); verify(delegate).scheduleAtFixedRate(argumentCaptor.capture(), eq(duration)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay) { return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), startTime, delay); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void scheduleWithFixedDelayWithDateAndLong() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); final Date date = new Date(); scheduler.scheduleWithFixedDelay(mockRunnable, date, 1000L); verify(delegate).scheduleWithFixedDelay(argumentCaptor.capture(), eq(date), eq(1000L)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); } @Test public void scheduleWithFixedDelayWithLong() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); scheduler.scheduleWithFixedDelay(mockRunnable, 1000L); verify(delegate).scheduleWithFixedDelay(argumentCaptor.capture(), eq(1000L)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); } @Test public void scheduleWithFixedDelayWithInstantAndDuration() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); final Instant instant = Instant.now(); final Duration duration = Duration.ofMinutes(1); scheduler.scheduleWithFixedDelay(mockRunnable, instant, duration); verify(delegate).scheduleWithFixedDelay(argumentCaptor.capture(), eq(instant), eq(duration)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); } @Test public void scheduleWithFixedDelayWithDuration() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); final Duration duration = Duration.ofMinutes(5); scheduler.scheduleWithFixedDelay(mockRunnable, duration); verify(delegate).scheduleWithFixedDelay(argumentCaptor.capture(), eq(duration)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadFactory(ThreadFactory threadFactory) { delegate.setThreadFactory(threadFactory); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void setThreadFactory() { final ThreadFactory threadFactory = mock(ThreadFactory.class); scheduler.setThreadFactory(threadFactory); verify(delegate).setThreadFactory(threadFactory); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadNamePrefix(String threadNamePrefix) { delegate.setThreadNamePrefix(threadNamePrefix); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void setThreadNamePrefix() { final String threadNamePrefix = "c137"; scheduler.setThreadNamePrefix(threadNamePrefix); verify(delegate).setThreadNamePrefix(threadNamePrefix); }
TracingChannelInterceptor extends ChannelInterceptorAdapter implements ExecutorChannelInterceptor { @Override public void afterMessageHandled(Message<?> message, MessageChannel channel, MessageHandler handler, Exception arg3) { if ((handler instanceof WebSocketAnnotationMethodMessageHandler || handler instanceof SubProtocolWebSocketHandler) && SimpMessageType.MESSAGE.equals(message.getHeaders().get(SIMP_MESSAGE_TYPE))) { message.getHeaders().get(OPENTRACING_SCOPE, Scope.class).close(); message.getHeaders().get(OPENTRACING_SPAN, Span.class).finish(); } } TracingChannelInterceptor(Tracer tracer, String spanKind); @Override Message<?> preSend(Message<?> message, MessageChannel channel); @Override void afterMessageHandled(Message<?> message, MessageChannel channel, MessageHandler handler, Exception arg3); @Override Message<?> beforeHandle(Message<?> message, MessageChannel channel, MessageHandler handler); }
@Test public void testAfterMessageHandled() { Span span = mock(Span.class); Scope scope = mock(Scope.class); MessageHandler messageHandler = mock(WebSocketAnnotationMethodMessageHandler.class); MessageBuilder<String> messageBuilder = MessageBuilder.withPayload("Hi") .setHeader(TracingChannelInterceptor.SIMP_MESSAGE_TYPE, SimpMessageType.MESSAGE) .setHeader(TracingChannelInterceptor.SIMP_DESTINATION, TEST_DESTINATION) .setHeader(TracingChannelInterceptor.OPENTRACING_SCOPE, scope) .setHeader(TracingChannelInterceptor.OPENTRACING_SPAN, span); TracingChannelInterceptor interceptor = new TracingChannelInterceptor(mockTracer, Tags.SPAN_KIND_CLIENT); interceptor.afterMessageHandled(messageBuilder.build(), null, messageHandler, null); verify(span).finish(); verify(scope).close(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler) { delegate.setRejectedExecutionHandler(rejectedExecutionHandler); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void setRejectedExecutionHandler() { final RejectedExecutionHandler rejectedExecutionHandler = mock(RejectedExecutionHandler.class); scheduler.setRejectedExecutionHandler(rejectedExecutionHandler); verify(delegate).setRejectedExecutionHandler(rejectedExecutionHandler); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown) { delegate.setWaitForTasksToCompleteOnShutdown(waitForJobsToCompleteOnShutdown); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void setWaitForTasksToCompleteOnShutdown() { scheduler.setWaitForTasksToCompleteOnShutdown(true); verify(delegate).setWaitForTasksToCompleteOnShutdown(true); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setAwaitTerminationSeconds(int awaitTerminationSeconds) { delegate.setAwaitTerminationSeconds(awaitTerminationSeconds); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void setAwaitTerminationSeconds() { scheduler.setAwaitTerminationSeconds(5); verify(delegate).setAwaitTerminationSeconds(5); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setBeanName(String name) { delegate.setBeanName(name); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void setBeanName() { final String name = "gazorp"; scheduler.setBeanName(name); verify(delegate).setBeanName(name); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void afterPropertiesSet() { delegate.afterPropertiesSet(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void afterPropertiesSet() { scheduler.afterPropertiesSet(); verify(delegate).afterPropertiesSet(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void initialize() { delegate.initialize(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void initialize() { scheduler.initialize(); verify(delegate).initialize(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void destroy() { delegate.destroy(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void destroy() { scheduler.destroy(); verify(delegate).destroy(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void shutdown() { delegate.shutdown(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void shutdown() { scheduler.shutdown(); verify(delegate).shutdown(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public Thread newThread(Runnable runnable) { return delegate.newThread(runnable); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void newThread() { final Runnable runnable = mock(Runnable.class); scheduler.newThread(runnable); verify(delegate).newThread(runnable); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public String getThreadNamePrefix() { return delegate.getThreadNamePrefix(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void getThreadNamePrefix() { scheduler.getThreadNamePrefix(); verify(delegate).getThreadNamePrefix(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setPoolSize(int poolSize) { delegate.setPoolSize(poolSize); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void setPoolSize() { scheduler.setPoolSize(10); verify(delegate).setPoolSize(10); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadPriority(int threadPriority) { delegate.setThreadPriority(threadPriority); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void setThreadPriority() { final int threadPriority = 5150; scheduler.setThreadPriority(threadPriority); verify(delegate).setThreadPriority(threadPriority); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public int getThreadPriority() { return delegate.getThreadPriority(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void getThreadPriority() { scheduler.getThreadPriority(); verify(delegate).getThreadPriority(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setDaemon(boolean daemon) { delegate.setDaemon(daemon); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void setDaemon() { scheduler.setDaemon(true); verify(delegate).setDaemon(true); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public boolean isDaemon() { return delegate.isDaemon(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void isDaemon() { scheduler.isDaemon(); verify(delegate).isDaemon(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadGroupName(String name) { delegate.setThreadGroupName(name); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void setThreadGroupName() { final String name = "crombopulous"; scheduler.setThreadGroupName(name); verify(delegate).setThreadGroupName(name); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadGroup(ThreadGroup threadGroup) { delegate.setThreadGroup(threadGroup); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void setThreadGroup() { final ThreadGroup threadGroup = mock(ThreadGroup.class); scheduler.setThreadGroup(threadGroup); verify(delegate).setThreadGroup(threadGroup); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override @Nullable public ThreadGroup getThreadGroup() { return delegate.getThreadGroup(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void getThreadGroup() { scheduler.getThreadGroup(); verify(delegate).getThreadGroup(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public Thread createThread(Runnable runnable) { return delegate.createThread(runnable); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void createThread() { final Runnable runnable = mock(Runnable.class); scheduler.createThread(runnable); verify(delegate).createThread(runnable); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public boolean prefersShortLivedTasks() { return delegate.prefersShortLivedTasks(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void prefersShortLivedTasks() { scheduler.prefersShortLivedTasks(); verify(delegate).prefersShortLivedTasks(); }
CustomAsyncConfigurerAutoConfiguration implements BeanPostProcessor, PriorityOrdered, BeanFactoryAware { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof AsyncConfigurer && !(bean instanceof TracedAsyncConfigurer)) { AsyncConfigurer configurer = (AsyncConfigurer) bean; Tracer tracer = this.beanFactory.getBean(Tracer.class); return new TracedAsyncConfigurer(tracer, configurer); } return bean; } @Override Object postProcessBeforeInitialization(Object bean, String beanName); @Override Object postProcessAfterInitialization(Object bean, String beanName); @Override int getOrder(); @Override void setBeanFactory(BeanFactory beanFactory); }
@Test public void should_return_bean_when_its_not_async_configurer() { CustomAsyncConfigurerAutoConfiguration configuration = new CustomAsyncConfigurerAutoConfiguration(); Object bean = configuration.postProcessAfterInitialization(new Object(), "someBean"); then(bean).isNotInstanceOf(TracedAsyncConfigurer.class); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy) { delegate.setRemoveOnCancelPolicy(removeOnCancelPolicy); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void setRemoveOnCancelPolicy() { scheduler.setRemoveOnCancelPolicy(true); verify(delegate).setRemoveOnCancelPolicy(true); }
TracingMongoClientPostProcessor implements BeanPostProcessor { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof MongoClient && !(bean instanceof TracingMongoClient)) { final MongoClient client = (MongoClient) bean; final TracingCommandListener commandListener = new TracingCommandListener.Builder(tracer) .build(); return new TracingMongoClient(commandListener, client.getServerAddressList(), client.getCredentialsList(), client.getMongoClientOptions()); } return bean; } TracingMongoClientPostProcessor(Tracer tracer); @Override Object postProcessAfterInitialization(Object bean, String beanName); }
@Test public void testNonMongoClientBeansAreReturnedUnaltered() { final Object expected = new Object(); final Object actual = processor.postProcessAfterInitialization(expected, "any-bean-name"); assertThat(actual).isSameAs(expected); } @Test public void testMongoClientBeansReplacedWithTracingClient() { final MongoClient client = new MongoClient(new MongoClientURI("mongodb: final Object actual = processor.postProcessAfterInitialization(client, "any-bean-name"); assertThat(actual).isInstanceOf(TracingMongoClient.class); } @Test public void testTracingMongoClientBeanNotWrapped() { final Object actual = processor.postProcessAfterInitialization(tracingClient, "any-bean-name"); assertThat(actual).isSameAs(tracingClient); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setErrorHandler(ErrorHandler errorHandler) { delegate.setErrorHandler(errorHandler); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void setErrorHandler() { final ErrorHandler errorHandler = mock(ErrorHandler.class); scheduler.setErrorHandler(errorHandler); verify(delegate).setErrorHandler(errorHandler); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledExecutorService getScheduledExecutor() throws IllegalStateException { return delegate.getScheduledExecutor(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void getScheduledExecutor() { scheduler.getScheduledExecutor(); verify(delegate).getScheduledExecutor(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor() throws IllegalStateException { return delegate.getScheduledThreadPoolExecutor(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void getScheduledThreadPoolExecutor() { scheduler.getScheduledThreadPoolExecutor(); verify(delegate).getScheduledThreadPoolExecutor(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public int getPoolSize() { return delegate.getPoolSize(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void getPoolSize() { scheduler.getPoolSize(); verify(delegate).getPoolSize(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public boolean isRemoveOnCancelPolicy() { return delegate.isRemoveOnCancelPolicy(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void isRemoveOnCancelPolicy() { scheduler.isRemoveOnCancelPolicy(); verify(delegate).isRemoveOnCancelPolicy(); }
LargeMessageProxy extends AbstractLoggingActor { public static Props props() { return Props.create(LargeMessageProxy.class); } static Props props(); @Override Receive createReceive(); static final String DEFAULT_NAME; }
@Test public void testSmallMessageSending() { new TestKit(system) { { ActorRef sender = system.actorOf(TestActor.props(this.getRef()), "sender"); ActorRef receiver = system.actorOf(TestActor.props(this.getRef()), "receiver"); within(Duration.ofSeconds(1), () -> { String shortMessage = "Hello, this is a short message!"; LargeMessageProxy.LargeMessage<String> shortStringMessage = new LargeMessageProxy.LargeMessage<String>(shortMessage, receiver); sender.tell(shortStringMessage, this.getRef()); this.expectMsg(shortMessage); assertTrue(this.getLastSender().equals(receiver)); expectNoMessage(); return null; }); } }; } @Test public void testLargeMessageSending() { new TestKit(system) { { ActorRef sender = system.actorOf(TestActor.props(this.getRef()), "sender"); ActorRef receiver = system.actorOf(TestActor.props(this.getRef()), "receiver"); within(Duration.ofSeconds(2), () -> { StringBuffer longMessageBuffer = new StringBuffer("Hello, this is a String message with a very large payload!"); for (int i = 0; i < 1000; i++) longMessageBuffer.append("<content>"); String longMessage = longMessageBuffer.toString(); LargeMessageProxy.LargeMessage<String> longStringMessage = new LargeMessageProxy.LargeMessage<String>(longMessage, receiver); sender.tell(longStringMessage, this.getRef()); this.expectMsg(longMessage); assertTrue(this.getLastSender().equals(receiver)); expectNoMessage(); return null; }); } }; }
Worker extends AbstractLoggingActor { public static Props props() { return Props.create(Worker.class); } static Props props(); @Override void preStart(); @Override void postStop(); @Override Receive createReceive(); }
@Test public void shouldFindCorrectPrimes() { new TestKit(this.actorSystem) {{ ActorRef worker = actorSystem.actorOf(Worker.props()); worker.tell(new Worker.ValidationMessage(0, 1, 10), this.getRef()); Master.PrimesMessage expectedMsg = new Master.PrimesMessage(0, Arrays.asList(2L, 3L, 5L, 7L), true); this.expectMsg(Duration.create(3, "secs"), expectedMsg); }}; } @Test public void shouldInterpretRangeCorrectly() { new TestKit(this.actorSystem) {{ ActorRef worker = actorSystem.actorOf(Worker.props()); worker.tell(new Worker.ValidationMessage(1, 5, 11), this.getRef()); Master.PrimesMessage expectedMsg = new Master.PrimesMessage(1, Arrays.asList(5L, 7L, 11L), true); this.expectMsg(Duration.create(3, "secs"), expectedMsg); }}; }
UserRepository { public LiveData<User> getUser(String email) { MutableLiveData<User> liveData = new MutableLiveData<>(); userDao.loadUser(email) .compose(transformers.applySchedulersToFlowable()) .subscribe(liveData::setValue, Timber::d); userApi.getUser(email) .compose(transformers.applySchedulersToFlowable()) .map(mapper::toEntity) .subscribe(userDao::saveUser, Timber::d); return liveData; } @Inject UserRepository(); LiveData<User> getUser(String email); LiveData<List<User>> getUsers(); LiveData<Boolean> saveUser(User user); }
@Test public void getUser() { User userEntity = new User("[email protected]", "John", "Doe"); com.jonathanpetitfrere.mvvm.repository.api.model.User userModel = mapper.toModel(userEntity); when(transformers.applySchedulersToFlowable()).thenReturn(flowable -> flowable); when(userDao.loadUser(anyString())).thenReturn(Flowable.just(userEntity)); when(userApi.getUser(anyString())).thenReturn(Flowable.just(userModel)); Observer<User> observer = mock(Observer.class); userRepository.getUser(anyString()) .observeForever(observer); verify(userDao, times(1)).loadUser(anyString()); verify(userApi, times(1)).getUser(anyString()); verify(userDao, times(1)).saveUser(userEntity); verify(observer, only()).onChanged(userEntity); }
UserRepository { public LiveData<List<User>> getUsers() { MutableLiveData<List<User>> liveData = new MutableLiveData<>(); userDao.loadUsers() .compose(transformers.applySchedulersToFlowable()) .subscribe(liveData::setValue, Timber::d); userApi.getUsers() .compose(transformers.applySchedulersToFlowable()) .flatMapIterable(users -> users) .map(mapper::toEntity) .subscribe(userDao::saveUser, Timber::d); return liveData; } @Inject UserRepository(); LiveData<User> getUser(String email); LiveData<List<User>> getUsers(); LiveData<Boolean> saveUser(User user); }
@Test public void getUsers() { User userEntityOne = new User("[email protected]", "John", "Doe"); User userEntityTwo = new User("[email protected]", "Jane", "Doe"); List<User> userEntities = new ArrayList<>(); List<com.jonathanpetitfrere.mvvm.repository.api.model.User> userModels = new ArrayList<>(); userEntities.add(userEntityOne); userEntities.add(userEntityTwo); userModels.add(mapper.toModel(userEntityOne)); userModels.add(mapper.toModel(userEntityTwo)); when(transformers.applySchedulersToFlowable()).thenReturn(flowable -> flowable); when(userDao.loadUsers()).thenReturn(Flowable.just(userEntities)); when(userApi.getUsers()).thenReturn(Flowable.just(userModels)); Observer<List<User>> observer = mock(Observer.class); userRepository.getUsers() .observeForever(observer); verify(userDao, times(userEntities.size())).saveUser(any()); verify(userApi, times(1)).getUsers(); verify(observer, only()).onChanged(userEntities); }
UserRepository { public LiveData<Boolean> saveUser(User user) { MutableLiveData<Boolean> liveData = new MutableLiveData<>(); Completable.fromAction(() -> userDao.saveUser(user)) .compose(transformers.applySchedulersToCompletable()) .subscribe(() -> liveData.setValue(true), throwable -> { Timber.d(throwable); liveData.setValue(false); }); return liveData; } @Inject UserRepository(); LiveData<User> getUser(String email); LiveData<List<User>> getUsers(); LiveData<Boolean> saveUser(User user); }
@Test public void saveUserSuccess() { User userEntity = new User("[email protected]", "John", "Doe"); when(transformers.applySchedulersToCompletable()).thenReturn(completable -> completable); Observer<Boolean> observer = mock(Observer.class); userRepository.saveUser(userEntity) .observeForever(observer); verify(userDao, times(1)).saveUser(userEntity); verify(observer, only()).onChanged(true); } @Test public void saveUserFail() { User userEntity = new User("[email protected]", "John", "Doe"); when(transformers.applySchedulersToCompletable()).thenReturn(completable -> completable); doThrow(Exception.class).when(userDao).saveUser(any()); Observer<Boolean> observer = mock(Observer.class); userRepository.saveUser(userEntity) .observeForever(observer); verify(userDao, times(1)).saveUser(userEntity); verify(observer, only()).onChanged(false); }
UserMapper { public User toModel(com.jonathanpetitfrere.mvvm.repository.persistence.entity.User userEntity) { return new User(userEntity.getEmail(), userEntity.getFirstName(), userEntity.getLastName()); } @Inject UserMapper(); User toModel(com.jonathanpetitfrere.mvvm.repository.persistence.entity.User userEntity); com.jonathanpetitfrere.mvvm.repository.persistence.entity.User toEntity(User userModel); }
@Test public void toModel() { User userEntity = new User("[email protected]", "First Name", "Last Name"); com.jonathanpetitfrere.mvvm.repository.api.model.User userModel = mapper.toModel(userEntity); assertEquals(userEntity.getEmail(), userModel.getEmail()); assertEquals(userEntity.getFirstName(), userModel.getFirstName()); assertEquals(userEntity.getLastName(), userModel.getLastName()); }
UserMapper { public com.jonathanpetitfrere.mvvm.repository.persistence.entity.User toEntity(User userModel) { return new com.jonathanpetitfrere.mvvm.repository.persistence.entity.User(userModel.getEmail(), userModel.getFirstName(), userModel.getLastName()); } @Inject UserMapper(); User toModel(com.jonathanpetitfrere.mvvm.repository.persistence.entity.User userEntity); com.jonathanpetitfrere.mvvm.repository.persistence.entity.User toEntity(User userModel); }
@Test public void toEntity() { com.jonathanpetitfrere.mvvm.repository.api.model.User userModel = new com.jonathanpetitfrere.mvvm.repository.api.model.User("[email protected]", "First Name", "Last Name"); User userEntity = mapper.toEntity(userModel); assertEquals(userModel.getEmail(), userEntity.getEmail()); assertEquals(userModel.getFirstName(), userEntity.getFirstName()); assertEquals(userModel.getLastName(), userEntity.getLastName()); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void unsubscribingScheduledWorksReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingAction()); worker.unsubscribe(); assertIdle(1); } @Test public void unsubscribingScheduledWorkWhileRunningWorkReportsBusy() { final Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new Action0() { @Override public void call() { worker.unsubscribe(); assertBusy(); } }); delegate.triggerActions(); } @Test public void scheduleWorkAfterUnsubscribedReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.unsubscribe(); worker.schedule(new CountingAction()); assertIdle(0); } @Test public void finishingWorkWithoutRegisteredCallbackDoesNotCrash() { IdlingResourceScheduler scheduler = RxIdler.wrap(delegate, "Bob"); Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingAction()); delegate.triggerActions(); } @Test public void creatingWorkerReportsIdle() { assertIdle(0); scheduler.createWorker(); assertIdle(0); } @Test public void scheduledWorkReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingAction()); assertBusy(); } @Test public void scheduledWorkUnsubscribedReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingAction()).unsubscribe(); assertIdle(1); } @Test public void scheduleWithZeroDelayReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingAction(), 0, SECONDS); assertBusy(); } @Test public void scheduleWithNonZeroDelayReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingAction(), 1, SECONDS); assertIdle(0); } @Test public void schedulePeriodicallyWithZeroDelayReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedulePeriodically(new CountingAction(), 0, 1, SECONDS); assertBusy(); } @Test public void schedulePeriodicallyWithNonZeroDelayReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedulePeriodically(new CountingAction(), 1, 1, SECONDS); assertIdle(0); } @Test public void betweenPeriodicSchedulesReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); CountingAction action = new CountingAction(); worker.schedulePeriodically(action, 0, 1, SECONDS); delegate.triggerActions(); assertEquals(1, action.count()); delegate.advanceTimeBy(500, MILLISECONDS); assertIdle(1); delegate.advanceTimeBy(1000, MILLISECONDS); assertIdle(2); } @Test public void runningWorkReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new Action0() { @Override public void call() { assertBusy(); } }); delegate.triggerActions(); }
RxIdler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name) { if (scheduler == null) throw new NullPointerException("scheduler == null"); if (name == null) throw new NullPointerException("name == null"); return new DelegatingIdlingResourceScheduler(scheduler, name); } private RxIdler(); @CheckResult @NonNull static RxJavaSchedulersHook hooks(); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name); }
@Test public void nullWrapArgumentsFails() { try { RxIdler.wrap(null, "Bob"); fail(); } catch (NullPointerException e) { assertEquals("scheduler == null", e.getMessage()); } try { RxIdler.wrap(new TestScheduler(), null); fail(); } catch (NullPointerException e) { assertEquals("name == null", e.getMessage()); } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public String getName() { return name; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void name() { assertEquals("Bob", scheduler.getName()); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void creatingWorkerReportsIdle() { assertIdle(0); scheduler.createWorker(); assertIdle(0); } @Test public void scheduledWorkReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable()); assertBusy(); } @Test public void scheduledWorkUnsubscribedReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable()).dispose(); assertIdle(1); } @Test public void scheduleWithZeroDelayReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable(), 0, SECONDS); assertBusy(); } @Test public void scheduleWithNonZeroDelayReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable(), 1, SECONDS); assertIdle(0); } @Test public void schedulePeriodicallyWithZeroDelayReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedulePeriodically(new CountingRunnable(), 0, 1, SECONDS); assertBusy(); } @Test public void schedulePeriodicallyWithNonZeroDelayReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedulePeriodically(new CountingRunnable(), 1, 1, SECONDS); assertIdle(0); } @Test public void betweenPeriodicSchedulesReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); CountingRunnable action = new CountingRunnable(); worker.schedulePeriodically(action, 0, 1, SECONDS); delegate.triggerActions(); assertEquals(1, action.count()); delegate.advanceTimeBy(500, MILLISECONDS); assertIdle(1); delegate.advanceTimeBy(1000, MILLISECONDS); assertIdle(2); } @Test public void runningWorkReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new Runnable() { @Override public void run() { assertBusy(); } }); delegate.triggerActions(); } @Test public void unsubscribingScheduledWorksReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable()); worker.dispose(); assertIdle(1); } @Test public void unsubscribingScheduledWorkWhileRunningWorkReportsBusy() { final Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new Runnable() { @Override public void run() { worker.dispose(); assertBusy(); } }); delegate.triggerActions(); } @Test public void scheduleWorkAfterUnsubscribedReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.dispose(); worker.schedule(new CountingRunnable()); assertIdle(0); } @Test public void finishingWorkWithoutRegisteredCallbackDoesNotCrash() { IdlingResourceScheduler scheduler = Rx2Idler.wrap(delegate, "Bob"); Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable()); delegate.triggerActions(); }
Rx2Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static Function<Callable<Scheduler>, Scheduler> create(@NonNull final String name) { if (name == null) throw new NullPointerException("name == null"); return new Function<Callable<Scheduler>, Scheduler>() { @Override public Scheduler apply(Callable<Scheduler> delegate) throws Exception { IdlingResourceScheduler scheduler = new DelegatingIdlingResourceScheduler(delegate.call(), name); IdlingRegistry.getInstance().register(scheduler); return scheduler; } }; } private Rx2Idler(); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static Function<Callable<Scheduler>, Scheduler> create(@NonNull final String name); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name); }
@Test public void createNullArgumentsFlow() { try { Rx2Idler.create(null); fail(); } catch (NullPointerException e) { assertEquals("name == null", e.getMessage()); } }
Rx2Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name) { if (scheduler == null) throw new NullPointerException("scheduler == null"); if (name == null) throw new NullPointerException("name == null"); return new DelegatingIdlingResourceScheduler(scheduler, name); } private Rx2Idler(); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static Function<Callable<Scheduler>, Scheduler> create(@NonNull final String name); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name); }
@Test public void nullWrapArgumentsFails() { try { Rx2Idler.wrap(null, "Bob"); fail(); } catch (NullPointerException e) { assertEquals("scheduler == null", e.getMessage()); } try { Rx2Idler.wrap(new TestScheduler(), null); fail(); } catch (NullPointerException e) { assertEquals("name == null", e.getMessage()); } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void creatingWorkerReportsIdle() { assertIdle(0); scheduler.createWorker(); assertIdle(0); } @Test public void scheduledWorkReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable()); assertBusy(); } @Test public void scheduledWorkUnsubscribedReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable()).dispose(); assertIdle(1); } @Test public void scheduleWithZeroDelayReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable(), 0, SECONDS); assertBusy(); } @Test public void scheduleWithNonZeroDelayReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable(), 1, SECONDS); assertIdle(0); } @Test public void schedulePeriodicallyWithZeroDelayReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedulePeriodically(new CountingRunnable(), 0, 1, SECONDS); assertBusy(); } @Test public void schedulePeriodicallyWithNonZeroDelayReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedulePeriodically(new CountingRunnable(), 1, 1, SECONDS); assertIdle(0); } @Test public void betweenPeriodicSchedulesReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); CountingRunnable action = new CountingRunnable(); worker.schedulePeriodically(action, 0, 1, SECONDS); delegate.triggerActions(); assertEquals(1, action.count()); delegate.advanceTimeBy(500, MILLISECONDS); assertIdle(1); delegate.advanceTimeBy(1000, MILLISECONDS); assertIdle(2); } @Test public void runningWorkReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(this::assertBusy); delegate.triggerActions(); } @Test public void unsubscribingScheduledWorksReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable()); worker.dispose(); assertIdle(1); } @Test public void unsubscribingScheduledWorkWhileRunningWorkReportsBusy() { final Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(() -> { worker.dispose(); assertBusy(); }); delegate.triggerActions(); } @Test public void scheduleWorkAfterUnsubscribedReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.dispose(); worker.schedule(new CountingRunnable()); assertIdle(0); } @Test public void finishingWorkWithoutRegisteredCallbackDoesNotCrash() { IdlingResourceScheduler scheduler = Rx3Idler.wrap(delegate, "Bob"); Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable()); delegate.triggerActions(); }
Rx3Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static Function<Supplier<Scheduler>, Scheduler> create(@NonNull final String name) { if (name == null) throw new NullPointerException("name == null"); return delegate -> { IdlingResourceScheduler scheduler = new DelegatingIdlingResourceScheduler(delegate.get(), name); IdlingRegistry.getInstance().register(scheduler); return scheduler; }; } private Rx3Idler(); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static Function<Supplier<Scheduler>, Scheduler> create(@NonNull final String name); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name); }
@Test public void createNullArgumentsFlow() { try { Rx3Idler.create(null); fail(); } catch (NullPointerException e) { assertEquals("name == null", e.getMessage()); } }
Rx3Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name) { if (scheduler == null) throw new NullPointerException("scheduler == null"); if (name == null) throw new NullPointerException("name == null"); return new DelegatingIdlingResourceScheduler(scheduler, name); } private Rx3Idler(); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static Function<Supplier<Scheduler>, Scheduler> create(@NonNull final String name); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name); }
@Test public void nullWrapArgumentsFails() { try { Rx3Idler.wrap(null, "Bob"); fail(); } catch (NullPointerException e) { assertEquals("scheduler == null", e.getMessage()); } try { Rx3Idler.wrap(new TestScheduler(), null); fail(); } catch (NullPointerException e) { assertEquals("name == null", e.getMessage()); } }
UrlUtils { public static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2) { int lengthDifference = url1.length() - url2.length(); if (lengthDifference == 0) { return url1.equalsIgnoreCase(url2); } else if (lengthDifference == 1) { return url1.charAt(url1.length() - 1) == '/' && url1.regionMatches(true, 0, url2, 0, url2.length()); } else if (lengthDifference == -1) { return url2.charAt(url2.length() - 1) == '/' && url2.regionMatches(true, 0, url1, 0, url1.length()); } return false; } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }
@Test public void urlsMatchExceptForTrailingSlash() throws Exception { assertTrue(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertTrue(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertTrue(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertFalse(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertFalse(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertFalse(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertFalse(UrlUtils.urlsMatchExceptForTrailingSlash("https: assertFalse(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertFalse(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertFalse(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertTrue(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertTrue(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertTrue(UrlUtils.urlsMatchExceptForTrailingSlash("http: }
SupportUtils { public static String normalize(@NonNull String input) { String trimmedInput = input.trim(); Uri uri = Uri.parse(trimmedInput); for (final String s : SupportUtils.SUPPORTED_URLS) { if (s.equals(input)) { return input; } } if (TextUtils.isEmpty(uri.getScheme())) { uri = Uri.parse("http: } return uri.toString(); } static String normalize(@NonNull String input); static boolean isUrl(@Nullable String url); static boolean isTemplateSupportPages(String url); static String getSumoURLForTopic(final Context context, final String topic); static String getManifestoURL(); static String getPrivacyURL(); static String getYourRightsURI(); static String getAboutURI(); static void loadSupportPages(WebView webview, String url); static final String BLANK_URL; static final String FOCUS_ABOUT_URL; static final String YOUR_RIGHTS_URI; static final String PRIVACY_URL; static final String ABOUT_URI; }
@Test public void testNormalize() { assertEquals("http: assertEquals("https: assertEquals("https: assertEquals("file: assertEquals("http: assertEquals("http: assertEquals("http: assertEquals("http: assertEquals("http: for (final String supported : SupportUtils.SUPPORTED_URLS) { assertEquals(supported, SupportUtils.normalize(supported)); } }
SupportUtils { public static boolean isUrl(@Nullable String url) { if (TextUtils.isEmpty(url)) { return false; } final String trimmedUrl = url.trim().toLowerCase(Locale.getDefault()); if (trimmedUrl.contains(" ")) { return false; } for (final String s : SupportUtils.SUPPORTED_URLS) { if (s.equals(trimmedUrl)) { return true; } } Uri uri = schemePattern.matcher(trimmedUrl).find() ? Uri.parse(trimmedUrl) : Uri.parse("http: final String host = TextUtils.isEmpty(uri.getHost()) ? "" : uri.getHost(); switch (uri.getScheme()) { case "http": case "https": if (!host.contains(".")) { return host.equals("localhost"); } return !host.startsWith(".") && !host.endsWith("."); case "file": return !TextUtils.isEmpty(uri.getPath()); default: return true; } } static String normalize(@NonNull String input); static boolean isUrl(@Nullable String url); static boolean isTemplateSupportPages(String url); static String getSumoURLForTopic(final Context context, final String topic); static String getManifestoURL(); static String getPrivacyURL(); static String getYourRightsURI(); static String getAboutURI(); static void loadSupportPages(WebView webview, String url); static final String BLANK_URL; static final String FOCUS_ABOUT_URL; static final String YOUR_RIGHTS_URI; static final String PRIVACY_URL; static final String ABOUT_URI; }
@Test public void testIsUrl() { assertTrue(SupportUtils.isUrl("http: assertTrue(SupportUtils.isUrl("https: assertTrue(SupportUtils.isUrl("https: assertTrue(SupportUtils.isUrl(" https: assertTrue(SupportUtils.isUrl(" https: assertTrue(SupportUtils.isUrl("https: assertTrue(SupportUtils.isUrl("file: assertTrue(SupportUtils.isUrl("file: assertTrue(SupportUtils.isUrl("file: assertTrue(SupportUtils.isUrl("mozilla.org")); assertTrue(SupportUtils.isUrl("192.168.1.1")); assertTrue(SupportUtils.isUrl("192.168.1.1:4000")); assertTrue(SupportUtils.isUrl("192.168.1.1/a/../b")); assertTrue(SupportUtils.isUrl("http: assertTrue(SupportUtils.isUrl("http: assertTrue(SupportUtils.isUrl("http: assertTrue(SupportUtils.isUrl("localhost")); assertTrue(SupportUtils.isUrl("http: assertTrue(SupportUtils.isUrl("about:blank")); assertTrue(SupportUtils.isUrl("focusabout:")); assertFalse(SupportUtils.isUrl("Hello World")); assertFalse(SupportUtils.isUrl("Mozilla")); assertFalse(SupportUtils.isUrl("")); assertFalse(SupportUtils.isUrl(" ")); assertFalse(SupportUtils.isUrl(":")); assertFalse(SupportUtils.isUrl(".")); assertFalse(SupportUtils.isUrl("::")); assertFalse(SupportUtils.isUrl("...")); assertFalse(SupportUtils.isUrl("file: }
SupportUtils { public static String getSumoURLForTopic(final Context context, final String topic) { String escapedTopic; try { escapedTopic = URLEncoder.encode(topic, "UTF-8"); } catch (UnsupportedEncodingException e) { throw new IllegalStateException("utf-8 should always be available", e); } final String appVersion; try { appVersion = context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionName; } catch (PackageManager.NameNotFoundException e) { throw new IllegalStateException("Unable find package details for Focus", e); } final String osTarget = "Android"; final String langTag = Locales.getLanguageTag(Locale.getDefault()); return "https: } static String normalize(@NonNull String input); static boolean isUrl(@Nullable String url); static boolean isTemplateSupportPages(String url); static String getSumoURLForTopic(final Context context, final String topic); static String getManifestoURL(); static String getPrivacyURL(); static String getYourRightsURI(); static String getAboutURI(); static void loadSupportPages(WebView webview, String url); static final String BLANK_URL; static final String FOCUS_ABOUT_URL; static final String YOUR_RIGHTS_URI; static final String PRIVACY_URL; static final String ABOUT_URI; }
@Test public void getSumoURLForTopic() throws Exception { final String appVersion; try { appVersion = ApplicationProvider.getApplicationContext().getPackageManager().getPackageInfo(ApplicationProvider.getApplicationContext().getPackageName(), 0).versionName; } catch (PackageManager.NameNotFoundException e) { throw new IllegalStateException("Unable find package details for Rocket", e); } Locale.setDefault(Locale.GERMANY); assertEquals("https: SupportUtils.getSumoURLForTopic(ApplicationProvider.getApplicationContext(), "foobar")); Locale.setDefault(Locale.CANADA_FRENCH); assertEquals("https: SupportUtils.getSumoURLForTopic(ApplicationProvider.getApplicationContext(), "foobar")); }
SupportUtils { public static String getManifestoURL() { final String langTag = Locales.getLanguageTag(Locale.getDefault()); return "https: } static String normalize(@NonNull String input); static boolean isUrl(@Nullable String url); static boolean isTemplateSupportPages(String url); static String getSumoURLForTopic(final Context context, final String topic); static String getManifestoURL(); static String getPrivacyURL(); static String getYourRightsURI(); static String getAboutURI(); static void loadSupportPages(WebView webview, String url); static final String BLANK_URL; static final String FOCUS_ABOUT_URL; static final String YOUR_RIGHTS_URI; static final String PRIVACY_URL; static final String ABOUT_URI; }
@Test public void getManifestoURL() throws Exception { Locale.setDefault(Locale.UK); assertEquals("https: SupportUtils.getManifestoURL()); Locale.setDefault(Locale.KOREA); assertEquals("https: SupportUtils.getManifestoURL()); }
ColorUtils { public static int getReadableTextColor(final int backgroundColor) { final int greyValue = grayscaleFromRGB(backgroundColor); if (greyValue < 186) { return Color.WHITE; } else { return Color.BLACK; } } static int getReadableTextColor(final int backgroundColor); }
@Test public void testGetReadableTextColor() { assertEquals(Color.BLACK, ColorUtils.getReadableTextColor(Color.WHITE)); assertEquals(Color.WHITE, ColorUtils.getReadableTextColor(Color.BLACK)); assertEquals(Color.BLACK, ColorUtils.getReadableTextColor(0xfff6f4ec)); assertEquals(Color.WHITE, ColorUtils.getReadableTextColor(0xffdb4437)); assertEquals(Color.WHITE, ColorUtils.getReadableTextColor(0xff527da3)); assertEquals(Color.BLACK, ColorUtils.getReadableTextColor(0xfff2f7fc)); assertEquals(Color.WHITE, ColorUtils.getReadableTextColor(0xfff57c00)); }
MimeUtils { public static boolean isText(@Nullable String type) { return !TextUtils.isEmpty(type) && textPattern.matcher(type).find(); } private MimeUtils(); static boolean isText(@Nullable String type); static boolean isImage(@Nullable String type); static boolean isAudio(@Nullable String type); static boolean isVideo(@Nullable String type); }
@Test public void testText() { assertTrue(MimeUtils.isText("text")); assertFalse(MimeUtils.isText("text/plain/")); assertFalse(MimeUtils.isText("text/plain*")); }
MimeUtils { public static boolean isImage(@Nullable String type) { return !TextUtils.isEmpty(type) && imgPattern.matcher(type).find(); } private MimeUtils(); static boolean isText(@Nullable String type); static boolean isImage(@Nullable String type); static boolean isAudio(@Nullable String type); static boolean isVideo(@Nullable String type); }
@Test public void testImage() { assertTrue(MimeUtils.isImage("image")); assertFalse(MimeUtils.isImage("image/png/")); assertFalse(MimeUtils.isImage("image/png*")); }
MimeUtils { public static boolean isAudio(@Nullable String type) { return !TextUtils.isEmpty(type) && audioPattern.matcher(type).find(); } private MimeUtils(); static boolean isText(@Nullable String type); static boolean isImage(@Nullable String type); static boolean isAudio(@Nullable String type); static boolean isVideo(@Nullable String type); }
@Test public void testAudio() { assertTrue(MimeUtils.isAudio("audio")); assertFalse(MimeUtils.isAudio("audio/mp3/")); assertFalse(MimeUtils.isAudio("audio/mp3*")); }
MimeUtils { public static boolean isVideo(@Nullable String type) { return !TextUtils.isEmpty(type) && videoPattern.matcher(type).find(); } private MimeUtils(); static boolean isText(@Nullable String type); static boolean isImage(@Nullable String type); static boolean isAudio(@Nullable String type); static boolean isVideo(@Nullable String type); }
@Test public void testVideo() { assertTrue(MimeUtils.isVideo("video")); assertFalse(MimeUtils.isVideo("video/mp4/")); assertFalse(MimeUtils.isVideo("video/mp4*")); }
UrlUtils { public static boolean isPermittedResourceProtocol(@NonNull final String scheme) { if (TextUtils.isEmpty(scheme)) { return false; } return scheme.startsWith("http") || scheme.startsWith("https") || scheme.startsWith("file") || scheme.startsWith("data"); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }
@Test public void isPermittedResourceProtocol() { assertTrue(UrlUtils.isPermittedResourceProtocol("http")); assertTrue(UrlUtils.isPermittedResourceProtocol("https")); assertTrue(UrlUtils.isPermittedResourceProtocol("data")); assertTrue(UrlUtils.isPermittedResourceProtocol("file")); assertFalse(UrlUtils.isPermittedResourceProtocol("nielsenwebid")); }
TabEntity { public boolean isValid() { final boolean hasId = !TextUtils.isEmpty(this.getId()); final boolean hasUrl = !TextUtils.isEmpty(this.getUrl()); return hasId && hasUrl; } @Ignore TabEntity(String id, String parentId); TabEntity(String id, String parentId, String title, String url); @NonNull String getId(); void setId(@NonNull String id); String getParentId(); void setParentId(String parentId); String getTitle(); void setTitle(String title); String getUrl(); void setUrl(String url); boolean isValid(); @Override String toString(); }
@Test public void testSanity() { Assert.assertFalse(new TabEntity(null, null).isValid()); Assert.assertFalse(new TabEntity(null, null, "title", "").isValid()); Assert.assertFalse(new TabEntity(null, null, null, "url").isValid()); Assert.assertFalse(new TabEntity("id", null, null, null).isValid()); Assert.assertTrue(new TabEntity("id", null, null, "url").isValid()); Assert.assertTrue(new TabEntity("id", null, "title", "url").isValid()); }
BrowsingSession { public static synchronized BrowsingSession getInstance() { if (instance == null) { instance = new BrowsingSession(); } return instance; } private BrowsingSession(); static synchronized BrowsingSession getInstance(); void countBlockedTracker(); void setBlockedTrackerCount(int count); void resetTrackerCount(); LiveData<Integer> getBlockedTrackerCount(); }
@Test public void testSingleton() { assertNotNull(BrowsingSession.getInstance()); assertEquals(BrowsingSession.getInstance(), BrowsingSession.getInstance()); }
SearchEngineParser { public static SearchEngine load(AssetManager assetManager, String identifier, String path) throws IOException { try (final InputStream stream = assetManager.open(path)) { return load(identifier, stream); } catch (XmlPullParserException e) { throw new AssertionError("Parser exception while reading " + path, e); } } static SearchEngine load(AssetManager assetManager, String identifier, String path); }
@Test public void testParser() throws Exception { final InputStream stream = new FileInputStream(searchPluginPath); final SearchEngine searchEngine = SearchEngineParser.load(searchEngineIdentifier, stream); assertEquals(searchEngineIdentifier, searchEngine.getIdentifier()); assertNotNull(searchEngine.getName()); assertFalse(TextUtils.isEmpty(searchEngine.getName())); assertNotNull(searchEngine.getIcon()); final String searchTerm = UUID.randomUUID().toString(); final String searchUrl = searchEngine.buildSearchUrl(searchTerm); assertNotNull(searchUrl); assertFalse(TextUtils.isEmpty(searchUrl)); assertTrue(searchUrl.contains(searchTerm)); stream.close(); }
UrlMatcher implements SharedPreferences.OnSharedPreferenceChangeListener { public boolean matches(final Uri resourceURI, final Uri pageURI) { final String path = resourceURI.getPath(); if (path == null) { return false; } if (blockWebfonts) { for (final String extension : WEBFONT_EXTENSIONS) { if (path.endsWith(extension)) { return true; } } } final String resourceURLString = resourceURI.toString(); if (previouslyUnmatched.contains(resourceURLString)) { return false; } if (entityList != null && entityList.isWhiteListed(pageURI, resourceURI)) { return false; } final String resourceHost = resourceURI.getHost(); final String pageHost = pageURI.getHost(); if (pageHost != null && pageHost.equals(resourceHost)) { return false; } if (previouslyMatched.contains(resourceURLString)) { return true; } final FocusString revhost = FocusString.create(resourceHost).reverse(); for (final Map.Entry<String, Trie> category : categories.entrySet()) { if (enabledCategories.contains(category.getKey()) && category.getValue().findNode(revhost) != null) { previouslyMatched.add(resourceURLString); return true; } } previouslyUnmatched.add(resourceURLString); return false; } UrlMatcher(final Context context, @NonNull final Map<String, String> categoryPrefMap, @NonNull final Map<String, Trie> categoryMap, @Nullable final EntityList entityList); @VisibleForTesting UrlMatcher(final String[] patterns); static UrlMatcher loadMatcher(final Context context, final int blockListFile, final int[] blockListOverrides, final int entityListFile, final int abpindo_adserversListFile); @Override void onSharedPreferenceChanged(final SharedPreferences sharedPreferences, final String prefName); Set<String> getCategories(); void setCategoryEnabled(final String category, final boolean enabled); boolean matches(final Uri resourceURI, final Uri pageURI); }
@Test public void matches() throws Exception { final UrlMatcher matcher = new UrlMatcher(new String[] { "bcd.random" }); assertTrue(matcher.matches(Uri.parse("http: assertTrue(matcher.matches(Uri.parse("http: assertTrue(matcher.matches(Uri.parse("http: assertTrue(matcher.matches(Uri.parse("http: assertTrue(matcher.matches(Uri.parse("http: assertTrue(matcher.matches(Uri.parse("http: assertTrue(!matcher.matches(Uri.parse("http: assertTrue(!matcher.matches(Uri.parse("http: assertTrue(!matcher.matches(Uri.parse("http: assertTrue(!matcher.matches(Uri.parse("http: assertTrue(!matcher.matches(Uri.parse("http: assertTrue(!matcher.matches(Uri.parse("http: assertTrue(!matcher.matches(Uri.parse("http: assertTrue(!matcher.matches(Uri.parse("http: assertFalse(matcher.matches(Uri.parse("http: assertTrue(matcher.matches(Uri.parse("http: } @Test public void categoriesWork() { final Map<String, Trie> categories = new HashMap<>(); final Map<String, String> categoryPrefMap = new HashMap<>(); final int CAT_COUNT = 4; final SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(ApplicationProvider.getApplicationContext()); { final SharedPreferences.Editor editor = preferences.edit(); for (int i = 0; i < CAT_COUNT; i++) { final String domain = "category" + i + ".com"; final Trie trie = Trie.createRootNode(); trie.put(FocusString.create(domain).reverse()); final String categoryName = "category" + i; categories.put(categoryName, trie); editor.putBoolean(categoryName, false); categoryPrefMap.put(categoryName, categoryName); } editor.apply(); } final UrlMatcher matcher = new UrlMatcher(ApplicationProvider.getApplicationContext(), categoryPrefMap, categories, null); final int allEnabledPattern = (1 << CAT_COUNT) - 1; for (int categoryPattern = 0; categoryPattern <= allEnabledPattern; categoryPattern++) { final SharedPreferences.Editor editor = preferences.edit(); for (int currentCategory = 0; currentCategory < CAT_COUNT; currentCategory++) { final int currentBit = 1 << currentCategory; final boolean enabled = ((currentBit & categoryPattern) == currentBit); editor.putBoolean("category" + currentCategory, enabled); if (categoryPattern == 0) { assertFalse("All categories should be disabled for categorypattern==0", enabled); } else if (categoryPattern == allEnabledPattern) { assertTrue("All categories should be enabled for categorypattern=='111....'", enabled); } else if (categoryPattern == Integer.parseInt("1100", 2)) { if (currentCategory < 2) { assertFalse("Categories 0/1 expected to be disabled", enabled); } else { assertTrue("Categories >= 2 expected to be enabled", enabled); } } } editor.apply(); for (int currentCategory = 0; currentCategory < CAT_COUNT; currentCategory++) { final int currentBit = 1 << currentCategory; final boolean enabled = ((currentBit & categoryPattern) == currentBit); final String url = "http: Assert.assertEquals("Incorrect category matched for combo=" + categoryPattern + " url=" + url, enabled, matcher.matches(Uri.parse(url), Uri.parse("http: } } }
Trie { public Trie findNode(final FocusString string) { if (terminator) { if (string.length() == 0 || string.charAt(0) == '.') { return this; } } else if (string.length() == 0) { return null; } final Trie next = children.get(string.charAt(0)); if (next == null) { return null; } return next.findNode(string.substring(1)); } private Trie(char character, Trie parent); Trie findNode(final FocusString string); Trie put(final FocusString string); Trie put(char character); static Trie createRootNode(); final SparseArray<Trie> children; public boolean terminator; }
@Test public void findNode() throws Exception { final Trie trie = Trie.createRootNode(); assertNull(trie.findNode(FocusString.create("hello"))); final Trie putNode = trie.put(FocusString.create("hello")); final Trie foundNode = trie.findNode(FocusString.create("hello")); assertNotNull(putNode); assertNotNull(foundNode); assertEquals(putNode, foundNode); assertNull(trie.findNode(FocusString.create("hell"))); assertNull(trie.findNode(FocusString.create("hellop"))); trie.put(FocusString.create("hellohello")); assertNotNull(trie.findNode(FocusString.create("hello"))); assertNotNull(trie.findNode(FocusString.create("hellohello"))); assertNull(trie.findNode(FocusString.create("hell"))); assertNull(trie.findNode(FocusString.create("hellop"))); trie.put(FocusString.create("foo.com").reverse()); assertNotNull(trie.findNode(FocusString.create("foo.com").reverse())); assertNotNull(trie.findNode(FocusString.create("bar.foo.com").reverse())); assertNull(trie.findNode(FocusString.create("bar-foo.com").reverse())); assertNull(trie.findNode(FocusString.create("oo.com").reverse())); }
TrackingProtectionWebViewClient extends WebViewClient { @Override public WebResourceResponse shouldInterceptRequest(final WebView view, final WebResourceRequest request) { if (!blockingEnabled) { return super.shouldInterceptRequest(view, request); } final Uri resourceUri = request.getUrl(); final String scheme = resourceUri.getScheme(); if (!request.isForMainFrame() && !scheme.equals("http") && !scheme.equals("https") && !scheme.equals("blob")) { return new WebResourceResponse(null, null, null); } final UrlMatcher matcher = getMatcher(view.getContext()); if ((currentPageURL != null && !request.isForMainFrame()) && matcher.matches(resourceUri, Uri.parse(currentPageURL))) { BrowsingSession.getInstance().countBlockedTracker(); return new WebResourceResponse(null, null, null); } return super.shouldInterceptRequest(view, request); } TrackingProtectionWebViewClient(final Context context); static void triggerPreload(final Context context); void setBlockingEnabled(boolean enabled); boolean isBlockingEnabled(); @Override WebResourceResponse shouldInterceptRequest(final WebView view, final WebResourceRequest request); void notifyCurrentURL(final String url); @Override void onPageStarted(WebView view, String url, Bitmap favicon); @Override void onReceivedHttpAuthRequest(WebView view, HttpAuthHandler handler, String host, String realm); }
@Test public void shouldInterceptRequest() throws Exception { trackingProtectionWebViewClient.notifyCurrentURL("http: { final WebResourceRequest request = createRequest("http: final WebResourceResponse response = trackingProtectionWebViewClient.shouldInterceptRequest(webView, request); assertResourceAllowed(response); } { final WebResourceRequest request = createRequest("http: final WebResourceResponse response = trackingProtectionWebViewClient.shouldInterceptRequest(webView, request); assertResourceBlocked(response); } }
WebViewProvider { @VisibleForTesting static String getUABrowserString(final String existingUAString, final String focusToken) { int start = existingUAString.indexOf("AppleWebKit"); if (start == -1) { start = existingUAString.indexOf(")") + 2; if (start >= existingUAString.length()) { return focusToken; } } final String[] tokens = existingUAString.substring(start).split(" "); for (int i = 0; i < tokens.length; i++) { if (tokens[i].startsWith("Chrome")) { tokens[i] = focusToken + " " + tokens[i]; return TextUtils.join(" ", tokens); } } return TextUtils.join(" ", tokens) + " " + focusToken; } static void preload(final Context context); static View create(final Context context, final AttributeSet attrs); static View create(final Context context, final AttributeSet attrs, final WebSettingsHook hook); static View createDefaultWebView(Context context, AttributeSet attrs); static void applyJavaScriptSettings(Context context, WebSettings settings); static void applyAppSettings(Context context, WebSettings settings); static void applyMultiTabSettings(Context context, WebSettings settings); static String getUserAgentString(Context context); }
@Test public void testGetUABrowserString() { String focusToken = "Focus/1.0"; final String existing = "Mozilla/5.0 (Linux; Android 5.0.2; Android SDK built for x86_64 Build/LSY66K) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/37.0.0.0 Mobile Safari/537.36"; assertEquals("AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 " + focusToken + " Chrome/37.0.0.0 Mobile Safari/537.36", WebViewProvider.getUABrowserString(existing, focusToken)); focusToken = "Klar/2.0"; assertEquals("AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 " + focusToken + " Chrome/37.0.0.0 Mobile Safari/537.36", WebViewProvider.getUABrowserString(existing, focusToken)); focusToken = "Focus/1.0"; final String imaginaryKit = "Mozilla/5.0 (Linux) ImaginaryKit/-10 (KHTML, like Gecko) Version/4.0 Chrome/37.0.0.0 Mobile Safari/537.36"; assertEquals("ImaginaryKit/-10 (KHTML, like Gecko) Version/4.0 " + focusToken + " Chrome/37.0.0.0 Mobile Safari/537.36", WebViewProvider.getUABrowserString(imaginaryKit, focusToken)); final String chromeless = "Mozilla/5.0 (Linux; Android 5.0.2; Android SDK built for x86_64 Build/LSY66K) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Imaginary/37.0.0.0 Mobile Safari/537.36"; assertEquals("AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Imaginary/37.0.0.0 Mobile Safari/537.36 " + focusToken, WebViewProvider.getUABrowserString(chromeless, focusToken)); final String chromelessImaginaryKit = "Mozilla/5.0 (Linux) ImaginaryKit/-10 (KHTML, like Gecko) Version/4.0 Imaginary/37.0.0.0 Mobile Safari/537.36"; assertEquals("ImaginaryKit/-10 (KHTML, like Gecko) Version/4.0 Imaginary/37.0.0.0 Mobile Safari/537.36 " + focusToken, WebViewProvider.getUABrowserString(chromelessImaginaryKit, focusToken)); }
DiskLruCache implements Closeable { public synchronized void close() throws IOException { if (journalWriter == null) { return; } for (Entry entry : new ArrayList<Entry>(lruEntries.values())) { if (entry.currentEditor != null) { entry.currentEditor.abort(); } } trimToSize(); journalWriter.close(); journalWriter = null; } private DiskLruCache(File directory, int appVersion, int valueCount, long maxSize); static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize); synchronized Value get(String key); Editor edit(String key); File getDirectory(); synchronized long getMaxSize(); synchronized void setMaxSize(long maxSize); synchronized long size(); synchronized boolean remove(String key); synchronized boolean isClosed(); synchronized void flush(); synchronized void close(); void delete(); }
@Test public void emptyCache() throws Exception { cache.close(); assertJournalEquals(); }
UrlUtils { public static boolean isSupportedProtocol(@NonNull final String scheme) { if (TextUtils.isEmpty(scheme)) { return false; } return isPermittedResourceProtocol(scheme) || scheme.startsWith("error"); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }
@Test public void isPermittedProtocol() { assertTrue(UrlUtils.isSupportedProtocol("http")); assertTrue(UrlUtils.isSupportedProtocol("https")); assertTrue(UrlUtils.isSupportedProtocol("error")); assertTrue(UrlUtils.isSupportedProtocol("data")); assertFalse(UrlUtils.isSupportedProtocol("market")); }
UrlUtils { public static boolean isSearchQuery(String text) { return text.contains(" "); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }
@Test public void testIsSearchQuery() { assertTrue(UrlUtils.isSearchQuery("hello world")); assertFalse(UrlUtils.isSearchQuery("mozilla.org")); assertFalse(UrlUtils.isSearchQuery("mozilla")); }
UrlUtils { public static String stripUserInfo(@Nullable String url) { if (TextUtils.isEmpty(url)) { return ""; } try { URI uri = new URI(url); final String userInfo = uri.getUserInfo(); if (userInfo == null) { return url; } uri = new URI(uri.getScheme(), null, uri.getHost(), uri.getPort(), uri.getPath(), uri.getQuery(), uri.getFragment()); return uri.toString(); } catch (URISyntaxException e) { return url; } } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }
@Test @SuppressLint("AuthLeak") public void testStripUserInfo() { assertEquals("", UrlUtils.stripUserInfo(null)); assertEquals("", UrlUtils.stripUserInfo("")); assertEquals("https: assertEquals("https: assertEquals("[email protected]", UrlUtils.stripUserInfo("[email protected]")); assertEquals("ftp: assertEquals("öäü102ß", UrlUtils.stripUserInfo("öäü102ß")); }
UrlUtils { public static boolean isInternalErrorURL(final String url) { return "data:text/html;charset=utf-8;base64,".equals(url); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }
@Test public void isInternalErrorURL() { assertTrue(UrlUtils.isInternalErrorURL("data:text/html;charset=utf-8;base64,")); assertFalse(UrlUtils.isInternalErrorURL("http: assertFalse(UrlUtils.isInternalErrorURL("https: assertFalse(UrlUtils.isInternalErrorURL("www.mozilla.org")); assertFalse(UrlUtils.isInternalErrorURL("error:-8")); assertFalse(UrlUtils.isInternalErrorURL("hello world")); }
UrlUtils { public static boolean isHttpOrHttps(String url) { if (TextUtils.isEmpty(url)) { return false; } return url.startsWith("http:") || url.startsWith("https:"); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }
@Test public void isHttpOrHttpsUrl() { assertFalse(UrlUtils.isHttpOrHttps(null)); assertFalse(UrlUtils.isHttpOrHttps("")); assertFalse(UrlUtils.isHttpOrHttps(" ")); assertFalse(UrlUtils.isHttpOrHttps("mozilla.org")); assertFalse(UrlUtils.isHttpOrHttps("httpstrf: assertTrue(UrlUtils.isHttpOrHttps("https: assertTrue(UrlUtils.isHttpOrHttps("http: assertTrue(UrlUtils.isHttpOrHttps("http: }
UrlUtils { public static String stripCommonSubdomains(@Nullable String host) { return stripPrefix(host, COMMON_SUBDOMAINS_PREFIX_ARRAY); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }
@Test public void stripCommonSubdomains() { assertEquals(UrlUtils.stripCommonSubdomains("m.mobile.com"), "mobile.com"); assertEquals(UrlUtils.stripCommonSubdomains("mobile.mozilla.org"), "mozilla.org"); assertEquals(UrlUtils.stripCommonSubdomains("www.synology.com"), "synology.com"); assertEquals(UrlUtils.stripCommonSubdomains("i.j.k"), "i.j.k"); }
UrlUtils { public static String stripHttp(@Nullable String host) { return stripPrefix(host, HTTP_SCHEME_PREFIX_ARRAY); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }
@Test public void stripHttp() { assertEquals(UrlUtils.stripHttp("http: assertEquals(UrlUtils.stripHttp("https: assertEquals(UrlUtils.stripHttp("ftp: assertEquals(UrlUtils.stripHttp("synology.com"), "synology.com"); }
TabUtil { public static Bundle argument(@Nullable final String parentId, boolean fromExternal, boolean toFocus) { final Bundle bundle = new Bundle(); if (!TextUtils.isEmpty(parentId)) { bundle.putString(ARG_PARENT_ID, parentId); } bundle.putBoolean(ARG_EXTERNAL, fromExternal); bundle.putBoolean(ARG_FOCUS, toFocus); return bundle; } private TabUtil(); static Bundle argument(@Nullable final String parentId, boolean fromExternal, boolean toFocus); @Nullable static String getParentId(@NonNull final Bundle bundle); static boolean isFromExternal(@NonNull final Bundle bundle); static boolean toFocus(@NonNull final Bundle bundle); }
@Test public void testCreation() { Assert.assertNotNull(TabUtil.argument("parent_id", false, false)); Assert.assertNotNull(TabUtil.argument(null, false, false)); Assert.assertNotNull(TabUtil.argument(null, false, true)); Assert.assertNotNull(TabUtil.argument(null, true, false)); }
RuleProviderSorter { public static List<RuleProvider> sort(List<RuleProvider> providers) { RuleProviderSorter sorter = new RuleProviderSorter(providers); return sorter.getProviders(); } private RuleProviderSorter(List<RuleProvider> providers); static List<RuleProvider> sort(List<RuleProvider> providers); }
@Test public void testSort() { AbstractRuleProvider v1 = new WCPPhase1Class1(); AbstractRuleProvider v2 = new WCPPhase1Class2(); AbstractRuleProvider vI = new WCPPhaseDependentClass2(); AbstractRuleProvider v3 = new WCPPhase1Class3(); AbstractRuleProvider v4 = new WCPPhase2Class1(); AbstractRuleProvider v5 = new WCPDependentPhase2Step2(); AbstractRuleProvider v6 = new WCPPhase2Class3(); AbstractRuleProvider v7 = new WCPPhase2Class4(); List<RuleProvider> ruleProviders = new ArrayList<>(); ruleProviders.add(v7); ruleProviders.add(v6); ruleProviders.add(vI); ruleProviders.add(v5); ruleProviders.add(v3); ruleProviders.add(v4); ruleProviders.add(v2); ruleProviders.add(v1); ruleProviders.addAll(getPhases()); List<RuleProvider> sortedRuleProviders = new ArrayList<>(RuleProviderSorter.sort(ruleProviders)); System.out.println("Results With Phases: " + sortedRuleProviders); ListIterator<RuleProvider> iterator = sortedRuleProviders.listIterator(); while (iterator.hasNext()) { RuleProvider p = iterator.next(); if (p instanceof RulePhase) { iterator.remove(); } } System.out.println("Results without Phases: " + sortedRuleProviders); Assert.assertEquals(v1, sortedRuleProviders.get(0)); Assert.assertEquals(v2, sortedRuleProviders.get(1)); Assert.assertEquals(vI, sortedRuleProviders.get(2)); Assert.assertEquals(v3, sortedRuleProviders.get(3)); Assert.assertEquals(v4, sortedRuleProviders.get(4)); Assert.assertEquals(v5, sortedRuleProviders.get(5)); Assert.assertEquals(v6, sortedRuleProviders.get(6)); Assert.assertEquals(v7, sortedRuleProviders.get(7)); } @Test public void testSortCycle() { WCPPhase1Class1 v1 = new WCPPhase1Class1(WCPPhase1Class3.class); AbstractRuleProvider v2 = new WCPPhase1Class2(); AbstractRuleProvider v3 = new WCPPhase1Class3(); AbstractRuleProvider v4 = new WCPPhase2Class1(); List<RuleProvider> ruleProviders = new ArrayList<>(); ruleProviders.add(v3); ruleProviders.add(v4); ruleProviders.add(v2); ruleProviders.add(v1); try { RuleProviderSorter.sort(ruleProviders); Assert.fail("No cycles detected"); } catch (RuntimeException e) { Assert.assertTrue(e.getMessage().contains("Dependency cycles detected")); } } @Test public void testImproperCrossPhaseDependency() { AbstractRuleProvider v1 = new WCPPhase1Class1(); AbstractRuleProvider v2 = new WCPPhase1Class2(); AbstractRuleProvider v3 = new WCPPhase1Class3(); AbstractRuleProvider v4 = new WCPPhase2Class1(); AbstractRuleProvider v5 = new WCPPhase2Class3(); AbstractRuleProvider v6 = new WCPPhase2Class4(); AbstractRuleProvider wrongPhaseDep = new WCPPhase1WrongPhaseDep(); List<RuleProvider> ruleProviders = new ArrayList<>(); ruleProviders.add(v6); ruleProviders.add(v5); ruleProviders.add(v3); ruleProviders.add(v4); ruleProviders.add(v2); ruleProviders.add(v1); ruleProviders.add(wrongPhaseDep); try { RuleProviderSorter.sort(ruleProviders); Assert.fail("No improper phase dependencies detected!"); } catch (IncorrectPhaseDependencyException | WindupMultiStringException e) { } } @Test public void testAcceptableCrossPhaseDependency() { AbstractRuleProvider v1 = new WCPPhase1Class1(); AbstractRuleProvider v2 = new WCPPhase1Class2(); AbstractRuleProvider v3 = new WCPPhase1Class3(); AbstractRuleProvider v4 = new WCPPhase2Class1(); AbstractRuleProvider v5 = new WCPDependentPhase2Step2(); AbstractRuleProvider v6 = new WCPPhase2Class3(); AbstractRuleProvider v7 = new WCPPhase2Class4(); AbstractRuleProvider acceptablePhaseDep = new WCPAcceptableCrossPhaseDep(); List<RuleProvider> ruleProviders = new ArrayList<>(); ruleProviders.add(v7); ruleProviders.add(v6); ruleProviders.add(v5); ruleProviders.add(v3); ruleProviders.add(v4); ruleProviders.add(v2); ruleProviders.add(v1); ruleProviders.add(acceptablePhaseDep); try { RuleProviderSorter.sort(ruleProviders); } catch (IncorrectPhaseDependencyException e) { e.printStackTrace(); Assert.fail("This cross-dependency should be acceptable!"); } } @Test public void testPhaseSorting() { List<RuleProvider> ruleProviders = new ArrayList<>(); ruleProviders.addAll(getPhases()); List<RuleProvider> results = RuleProviderSorter.sort(ruleProviders); Assert.assertEquals(4, results.size()); int row = 0; Assert.assertTrue(results.get(row) instanceof Phase1); Assert.assertTrue(results.get(row).getMetadata().getExecuteAfter().isEmpty()); Assert.assertEquals(1, results.get(row).getMetadata().getExecuteBefore().size()); Assert.assertTrue(results.get(row).getMetadata().getExecuteBefore().get(0) == Phase2.class); row++; Assert.assertTrue(results.get(row) instanceof Phase2); Assert.assertEquals(1, results.get(row).getMetadata().getExecuteAfter().size()); Assert.assertEquals(1, results.get(row).getMetadata().getExecuteBefore().size()); Assert.assertTrue(results.get(row).getMetadata().getExecuteAfter().get(0) == Phase1.class); Assert.assertTrue(results.get(row).getMetadata().getExecuteBefore().get(0) == Phase3.class); row++; Assert.assertTrue(results.get(row) instanceof Phase3); Assert.assertEquals(1, results.get(row).getMetadata().getExecuteAfter().size()); Assert.assertEquals(1, results.get(row).getMetadata().getExecuteBefore().size()); Assert.assertTrue(results.get(row).getMetadata().getExecuteAfter().get(0) == Phase2.class); Assert.assertTrue(results.get(row).getMetadata().getExecuteBefore().get(0) == Phase4.class); row++; Assert.assertTrue(results.get(row) instanceof Phase4); Assert.assertEquals(1, results.get(row).getMetadata().getExecuteAfter().size()); Assert.assertEquals(0, results.get(row).getMetadata().getExecuteBefore().size()); Assert.assertTrue(results.get(row).getMetadata().getExecuteAfter().get(0) == Phase3.class); Assert.assertTrue(results.get(row).getMetadata().getExecuteBefore().isEmpty()); }
TaggedRuleProviderPredicate implements Predicate<RuleProvider> { @Override public boolean accept(RuleProvider provider) { Set<String> tags = provider.getMetadata().getTags(); boolean result = true; if (!includeTags.isEmpty()) { if (requireAllIncludeTags) result = tags.containsAll(includeTags); else result = CollectionUtils.containsAny(tags, includeTags); } if (result && !excludeTags.isEmpty()) { if (requireAllExcludeTags) result = !tags.containsAll(excludeTags); else result = !CollectionUtils.containsAny(tags, excludeTags); } return result; } TaggedRuleProviderPredicate(Collection<String> includeTags, Collection<String> excludeTags); TaggedRuleProviderPredicate setRequireAllIncludeTags(boolean requireAll); TaggedRuleProviderPredicate setRequireAllExcludeTags(boolean requireAll); @Override boolean accept(RuleProvider provider); @Override String toString(); }
@Test public void testAccept() { TestTagsARules rulesA = new TestTagsARules(); TestTagsBRules rulesB = new TestTagsBRules(); TestTagsA1B1Rules rulesA1B1 = new TestTagsA1B1Rules(); Assert.assertEquals(true, isProviderAcceptedByTags(rulesA, Arrays.asList("tagA1"), false, null, false)); Assert.assertEquals(false, isProviderAcceptedByTags(rulesB, Arrays.asList("tagA1"), false, null, false)); Assert.assertEquals(true, isProviderAcceptedByTags(rulesB, Arrays.asList("tagA1", "tagB1"), false, null, false)); Assert.assertEquals(false, isProviderAcceptedByTags(rulesB, Arrays.asList("tagA1", "tagB1"), true, null, false)); Assert.assertEquals(true, isProviderAcceptedByTags(rulesB, Arrays.asList("tagA1", "tagB1", "tagC1"), false, null, false)); Assert.assertEquals(false, isProviderAcceptedByTags(rulesB, Arrays.asList("tagA1", "tagB1", "tagC1"), true, null, false)); Assert.assertEquals(true, isProviderAcceptedByTags(rulesA1B1, Arrays.asList("tagA1", "tagB1"), false, Arrays.asList("tagC1"), false)); Assert.assertEquals(false, isProviderAcceptedByTags(rulesA1B1, Arrays.asList("tagA1", "tagC1"), false, Arrays.asList("tagB1"), false)); Assert.assertEquals(false, isProviderAcceptedByTags(rulesA1B1, Arrays.asList("tagA1"), false, Arrays.asList("tagB1", "tagC1"), false)); Assert.assertEquals(true, isProviderAcceptedByTags(rulesA1B1, Arrays.asList("tagA1"), false, Arrays.asList("tagB1", "tagC1"), true)); }
PathUtil { public static Path getWindupUserDir() { String userHome = System.getProperty("user.home"); if (userHome == null) { Path path = new File("").toPath(); LOG.warning("$USER_HOME not set, using [" + path.toAbsolutePath().toString() + "] instead."); return path; } return Paths.get(userHome).resolve(".mta"); } static Path getWindupUserDir(); static Path getWindupHome(); static void setWindupHome(Path windupHome); static Path getUserCacheDir(); static Path getWindupCacheDir(); static Path getUserIgnoreDir(); static Path getWindupIgnoreDir(); static Path getWindupAddonsDir(); static Path getUserRulesDir(); static Path getUserLabelsDir(); static Path getWindupRulesDir(); static Path getWindupLabelsDir(); static String cleanFileName(String badFileName); static String classFilePathToClassname(String relativePath); static Path getRootFolderForSource(Path sourceFilePath, String packageName); static boolean isInSubDirectory(File dir, File file); static String pathToPackageName(String relativePath); static void createDirectory(Path dir, String dirDesc); static final String WINDUP_HOME; static final String WINDUP_RULESETS_DIR_SYSPROP; static final String WINDUP_LABELSETS_DIR_SYSPROP; static final String RULES_DIRECTORY_NAME; static final String LABELS_DIRECTORY_NAME; static final String IGNORE_DIRECTORY_NAME; static final String CACHE_DIRECTORY_NAME; static final String ADDONS_DIRECTORY_NAME; static String LIBRARY_DIRECTORY_NAME; static String BINARY_DIRECTORY_NAME; }
@Test public void testWindupUserDir() { Assert.assertEquals(Paths.get(""), PathUtil.getWindupUserDir()); setUserHome("/foo"); Assert.assertEquals(Paths.get("/foo", ".mta"), PathUtil.getWindupUserDir()); }
PathUtil { public static Path getUserIgnoreDir() { return getUserSubdirectory(IGNORE_DIRECTORY_NAME); } static Path getWindupUserDir(); static Path getWindupHome(); static void setWindupHome(Path windupHome); static Path getUserCacheDir(); static Path getWindupCacheDir(); static Path getUserIgnoreDir(); static Path getWindupIgnoreDir(); static Path getWindupAddonsDir(); static Path getUserRulesDir(); static Path getUserLabelsDir(); static Path getWindupRulesDir(); static Path getWindupLabelsDir(); static String cleanFileName(String badFileName); static String classFilePathToClassname(String relativePath); static Path getRootFolderForSource(Path sourceFilePath, String packageName); static boolean isInSubDirectory(File dir, File file); static String pathToPackageName(String relativePath); static void createDirectory(Path dir, String dirDesc); static final String WINDUP_HOME; static final String WINDUP_RULESETS_DIR_SYSPROP; static final String WINDUP_LABELSETS_DIR_SYSPROP; static final String RULES_DIRECTORY_NAME; static final String LABELS_DIRECTORY_NAME; static final String IGNORE_DIRECTORY_NAME; static final String CACHE_DIRECTORY_NAME; static final String ADDONS_DIRECTORY_NAME; static String LIBRARY_DIRECTORY_NAME; static String BINARY_DIRECTORY_NAME; }
@Test public void testWindupIgnoreDir() { Assert.assertEquals(Paths.get("ignore"), PathUtil.getUserIgnoreDir()); setUserHome("/foo"); Assert.assertEquals(Paths.get("/foo", ".mta", "ignore"), PathUtil.getUserIgnoreDir()); }
TickCounter { public TickCounter(TickHandler tickHandler, int maxTicks, int tickDuration) { this(tickHandler, maxTicks, tickDuration, 0); } TickCounter(TickHandler tickHandler, int maxTicks, int tickDuration); TickCounter(TickHandler tickHandler, int maxTicks, int tickDuration, int tickOffset); boolean update(); void reset(); int getTickCount(); boolean isRightTick(int tickInterval); }
@Test public void testTickCounter() { int maxTicks = 75; int tickDuration = 30; int deltaMultiplier = 5; t = new TickCounter(new TickHandler() { @Override public void onTick() { tickCount++; } @Override public int getDeltaMultiplier() { return deltaMultiplier; } }, maxTicks, tickDuration); long startTime = System.currentTimeMillis(); while (!t.update()) { } long duration = System.currentTimeMillis() - startTime; assertEquals(tickCount, t.getTickCount()); assertEquals(maxTicks, t.getTickCount()); assertEquals(maxTicks * tickDuration / deltaMultiplier, duration); assertEquals(false, t.update()); assertEquals(tickCount, t.getTickCount()); assertEquals(maxTicks, t.getTickCount()); t.reset(); tickCount = 0; while (!t.update()) { } assertEquals(tickCount, t.getTickCount()); }
CollectionUtils { public static synchronized <T, E> T getKeyByValue(Map<T, E> map, E value) { Preconditions.checkNotNull(map, "The map cannot be null"); for (Entry<T, E> entry : map.entrySet()) { if (Objects.equals(value, entry.getValue())) { return entry.getKey(); } } return null; } private CollectionUtils(); static synchronized T getKeyByValue(Map<T, E> map, E value); static Map<K, V> sortByValue( Map<K, V> map); static T findMostPopularElement( List<T> list); }
@Test public void testKeyByValue() { Map<Integer, Integer> map = new HashMap<>(); map.put(1, 1); map.put(2, 4); map.put(3, 9); map.put(4, 16); assertEquals((Integer) 1, CollectionUtils.getKeyByValue(map, 1)); assertEquals((Integer) 2, CollectionUtils.getKeyByValue(map, 4)); assertEquals((Integer) 3, CollectionUtils.getKeyByValue(map, 9)); assertEquals((Integer) 4, CollectionUtils.getKeyByValue(map, 16)); assertEquals(null, CollectionUtils.getKeyByValue(map, 5)); }
CollectionUtils { public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue( Map<K, V> map) { Preconditions.checkNotNull(map, "The map cannot be null"); List<Entry<K, V>> list = new ArrayList<>(map.entrySet()); list.sort(Entry.comparingByValue()); Map<K, V> result = new LinkedHashMap<>(); for (Entry<K, V> entry : list) { result.put(entry.getKey(), entry.getValue()); } return result; } private CollectionUtils(); static synchronized T getKeyByValue(Map<T, E> map, E value); static Map<K, V> sortByValue( Map<K, V> map); static T findMostPopularElement( List<T> list); }
@Test public void testSortByValue() { Map<Integer, Integer> map = new HashMap<>(); map.put(1, 16); map.put(2, 8); map.put(3, 9); map.put(4, 5); map.put(5, 15); map = CollectionUtils.sortByValue(map); Integer[] tmp = map.keySet().toArray(new Integer[5]); assertEquals((Integer) 1, tmp[4]); assertEquals((Integer) 5, tmp[3]); assertEquals((Integer) 3, tmp[2]); assertEquals((Integer) 2, tmp[1]); assertEquals((Integer) 4, tmp[0]); }
CollectionUtils { public static <T extends Comparable<T>> T findMostPopularElement( List<T> list) { Preconditions.checkNotNull(list, "The list cannot be null"); Collections.sort(list); T previous = list.get(0); T popular = list.get(0); int count = 1; int maxCount = 1; for (int i = 1; i < list.size(); i++) { if (list.get(i) == previous) count++; else { if (count > maxCount) { popular = list.get(i - 1); maxCount = count; } previous = list.get(i); count = 1; } } return count > maxCount ? list.get(list.size() - 1) : popular; } private CollectionUtils(); static synchronized T getKeyByValue(Map<T, E> map, E value); static Map<K, V> sortByValue( Map<K, V> map); static T findMostPopularElement( List<T> list); }
@Test public void testFindMostPopular() { Integer[] array = {1, 2, 2, 3, 4, 5, 5, 5, 6, 7, 7, 8}; List<Integer> list = new ArrayList<>(Arrays.asList(array)); assertEquals((Integer) 5, CollectionUtils.findMostPopularElement(list)); }
JwtUserFactory { public static JwtUser create(User user) { return new JwtUser( user.getId(), user.getUsername(), user.getFirstname(), user.getLastname(), user.getPassword(), user.getEmail(), user.getEnabled(), user.getLastPasswordResetDate().getTime(), mapUserRolesToGrantedAuthorities(user.getRoles()), user.getRoles() ); } private JwtUserFactory(); static JwtUser create(User user); }
@Test public void whenCreateCalledWithUserModelThenExpectJwtUserDetailsToBeReturned() throws Exception { final User user = new User(); user.setId(USER_ID); user.setUsername(USERNAME); user.setPassword(PASSWORD); user.setFirstname(FIRSTNAME); user.setLastname(LASTNAME); user.setEmail(EMAIL); user.setEnabled(USER_ENABLED); user.setLastPasswordResetDate(LAST_PASSWORD_RESET_DATE); user.setRoles(createRoles(user)); final JwtUser userDetails = JwtUserFactory.create(user); assertEquals(userDetails.getId(), USER_ID); assertEquals(userDetails.getUsername(), USERNAME); assertEquals(userDetails.getPassword(), PASSWORD); assertEquals(userDetails.getFirstname(), FIRSTNAME); assertEquals(userDetails.getLastname(), LASTNAME); assertEquals(userDetails.getEmail(), EMAIL); assertEquals(userDetails.isEnabled(), USER_ENABLED); assertEquals(userDetails.getLastPasswordResetDate(), LAST_PASSWORD_RESET_DATE.getTime()); assertTrue(userDetails.getRoles().contains(RoleName.ROLE_ADMIN.name())); assertTrue(userDetails.getRoles().contains(RoleName.ROLE_USER.name())); assertTrue(userDetails.getAuthorities().contains(new SimpleGrantedAuthority(RoleName.ROLE_ADMIN.name()))); assertTrue(userDetails.getAuthorities().contains(new SimpleGrantedAuthority(RoleName.ROLE_USER.name()))); }
JwtAuthenticationEntryPoint implements AuthenticationEntryPoint { @Override public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException { response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized"); } @Override void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException); }
@Test public void whenCommenceCalledThenExpectUnauthorizedResponse() throws Exception { final JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint = new JwtAuthenticationEntryPoint(); jwtAuthenticationEntryPoint.commence(request, response, authException); verify(response, times(1)).sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized"); }
JwtAuthenticationFilter extends OncePerRequestFilter { @Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException { try { String authorizationHeader = request.getHeader(AUTHORIZATION_HEADER); if (authorizationHeader != null && authorizationHeader.startsWith(BEARER_PREFIX)) { authorizationHeader = authorizationHeader.substring(BEARER_PREFIX_LENGTH); } if (authorizationHeader != null) { final Claims claims = jwtUtils.validateTokenAndGetClaims(authorizationHeader); final String username = jwtUtils.getUsernameFromTokenClaims(claims); LOG.info(() -> "Username in JWT: " + username); if (SecurityContextHolder.getContext().getAuthentication() == null) { LOG.info(() -> "JWT is valid"); final UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken( username, null, jwtUtils.getRolesFromTokenClaims(claims)); authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request)); SecurityContextHolder.getContext().setAuthentication(authentication); LOG.info(() -> "Authenticated User: " + username + " has been set in Spring SecurityContext."); } } chain.doFilter(request, response); } catch (Exception e) { LOG.error("JWT Authentication failure! Details: " + e.getMessage(), e); response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized"); } } @Autowired void setJwtUtils(JwtUtils jwtUtils); @Autowired void setUserDetailsService(UserDetailsService userDetailsService); }
@Test public void whenFilterCalledWithoutAuthorizationHeaderThenCallNextFilterInChain() throws Exception { when(request.getHeader(AUTHORIZATION_HEADER)).thenReturn(null); jwtAuthenticationFilter.doFilterInternal(request, response, filterChain); verify(request, times(1)).getHeader(AUTHORIZATION_HEADER); verify(filterChain, times(1)).doFilter(request, response); } @Test public void whenFilterCalledWithBearerTokenWithMissingUsernameThenCallNextFilterInChain() throws Exception { when(request.getHeader(AUTHORIZATION_HEADER)).thenReturn(BEARER_PREFIX + "dummy-token"); jwtAuthenticationFilter.doFilterInternal(request, response, filterChain); verify(request, times(1)).getHeader(AUTHORIZATION_HEADER); verify(jwtUtils, times(1)).getUsernameFromTokenClaims(any()); verify(filterChain, times(1)).doFilter(request, response); } @Test public void whenFilterCalledWithTokenWithMissingUsernameThenCallNextFilterInChain() throws Exception { when(request.getHeader(AUTHORIZATION_HEADER)).thenReturn("dummy-token"); when(jwtUtils.getUsernameFromTokenClaims((any()))).thenReturn(null); jwtAuthenticationFilter.doFilterInternal(request, response, filterChain); verify(request, times(1)).getHeader(AUTHORIZATION_HEADER); verify(jwtUtils, times(1)).getUsernameFromTokenClaims(any()); verify(filterChain, times(1)).doFilter(request, response); } @Test public void whenFilterCalledWithInvalidTokenThenCallNextFilterInChain() throws Exception { when(request.getHeader(AUTHORIZATION_HEADER)).thenReturn("dummy-token"); when(jwtUtils.getUsernameFromTokenClaims((any()))).thenReturn(USERNAME); when(jwtUtils.validateTokenAndGetClaims((any()))).thenReturn(claims); jwtAuthenticationFilter.doFilterInternal(request, response, filterChain); verify(request, times(1)).getHeader(AUTHORIZATION_HEADER); verify(jwtUtils, times(1)).getUsernameFromTokenClaims(any()); verify(jwtUtils, times(1)).validateTokenAndGetClaims(any()); verify(filterChain, times(1)).doFilter(request, response); } @Test public void whenFilterCalledWithValidTokenThenExpectSuccessfulAuthenticationAndCallNextFilterInChain() throws Exception { when(request.getHeader(AUTHORIZATION_HEADER)).thenReturn("dummy-token"); when(jwtUtils.getUsernameFromTokenClaims((any()))).thenReturn(USERNAME); when(jwtUtils.validateTokenAndGetClaims((any()))).thenReturn(claims); jwtAuthenticationFilter.doFilterInternal(request, response, filterChain); verify(request, times(1)).getHeader(AUTHORIZATION_HEADER); verify(jwtUtils, times(1)).getUsernameFromTokenClaims(any()); verify(jwtUtils, times(1)).validateTokenAndGetClaims(any()); verify(jwtUtils, times(1)).getRolesFromTokenClaims(any()); verify(filterChain, times(1)).doFilter(request, response); }
JwtUserDetailsService implements UserDetailsService { @Override public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { final User user = userRepository.findByUsername(username); if (user == null) { throw new UsernameNotFoundException(String.format("No user found with username '%s'.", username)); } else { return JwtUserFactory.create(user); } } @Autowired JwtUserDetailsService(UserRepository userRepository); @Override UserDetails loadUserByUsername(String username); }
@Test public void whenLoadByUsernameCalledWithKnownUsernameThenExpectUserDetailsToBeReturned() throws Exception { PowerMock.mockStatic(JwtUserFactory.class); final User user = PowerMock.createMock(User.class); final JwtUser jwtUser = EasyMock.createMock(JwtUser.class); expect(userRepository.findByUsername(KNOWN_USERNAME)).andStubReturn(user); expect(JwtUserFactory.create(eq(user))).andStubReturn(jwtUser); PowerMock.replayAll(); final JwtUserDetailsService jwtUserDetailsService = new JwtUserDetailsService(userRepository); final JwtUser userDetails = (JwtUser) jwtUserDetailsService.loadUserByUsername(KNOWN_USERNAME); assertEquals(jwtUser, userDetails); PowerMock.verifyAll(); } @Test(expected = UsernameNotFoundException.class) public void whenLoadByUsernameCalledWithUnknownUsernameThenExpectUsernameNotFoundException() throws Exception { expect(userRepository.findByUsername(UNKNOWN_USERNAME)).andStubReturn(null); PowerMock.replayAll(); final JwtUserDetailsService jwtUserDetailsService = new JwtUserDetailsService(userRepository); jwtUserDetailsService.loadUserByUsername(UNKNOWN_USERNAME); PowerMock.verifyAll(); }
BotStatusController extends AbstractRuntimeController { @PreAuthorize("hasRole('USER')") @RequestMapping(value = "/{botId}" + STATUS_RESOURCE_PATH, method = RequestMethod.GET) public ResponseEntity<?> getBotStatus(@AuthenticationPrincipal User user, @PathVariable String botId) { LOG.info("GET " + RUNTIME_ENDPOINT_BASE_URI + botId + STATUS_RESOURCE_PATH + " - getBotStatus()"); final BotStatus botStatus = botProcessService.getBotStatus(botId); return botStatus == null ? new ResponseEntity<>(HttpStatus.NOT_FOUND) : buildResponseEntity(botStatus, HttpStatus.OK); } @Autowired BotStatusController(BotStatusService botProcessService); @PreAuthorize("hasRole('USER')") @RequestMapping(value = "/{botId}" + STATUS_RESOURCE_PATH, method = RequestMethod.GET) ResponseEntity<?> getBotStatus(@AuthenticationPrincipal User user, @PathVariable String botId); @PreAuthorize("hasRole('USER')") @RequestMapping(value = STATUS_RESOURCE_PATH, method = RequestMethod.GET) ResponseEntity<?> getAllBotStatus(@AuthenticationPrincipal User user); }
@Test public void whenGetBotStatusCalledWhenUserIsAuthenticatedThenExpectSuccess() throws Exception { given(botProcessService.getBotStatus(BOT_1_ID)).willReturn(bot1Status); mockMvc.perform(get(RUNTIME_ENDPOINT_BASE_URI + BOT_1_ID + STATUS_RESOURCE_PATH) .header("Authorization", "Bearer " + getJwt(VALID_USER_NAME, VALID_USER_PASSWORD))) .andDo(print()) .andExpect(status().isOk()) .andExpect(jsonPath("$.data.id").value(BOT_1_ID)) .andExpect(jsonPath("$.data.name").value(BOT_1_NAME)) .andExpect(jsonPath("$.data.status").value(BOT_1_STATUS)); verify(botProcessService, times(1)).getBotStatus(BOT_1_ID); } @Test public void whenGetBotStatusCalledWithUnknownBotIdThenExpectNotFoundResponse() throws Exception { given(botProcessService.getBotStatus(UNKNOWN_BOT_ID)).willReturn(null); mockMvc.perform(get(RUNTIME_ENDPOINT_BASE_URI + UNKNOWN_BOT_ID + STATUS_RESOURCE_PATH) .header("Authorization", "Bearer " + getJwt(VALID_USER_NAME, VALID_USER_PASSWORD))) .andDo(print()) .andExpect(status().isNotFound()); verify(botProcessService, times(1)).getBotStatus(UNKNOWN_BOT_ID); }
JwtUtils { public String getUsernameFromTokenClaims(Claims claims) { try { final String username = claims.getSubject(); if (username == null) { final String errorMsg = "Failed to extract username claim from token!"; LOG.error(errorMsg); throw new JwtAuthenticationException(errorMsg); } return username; } catch (Exception e) { final String errorMsg = "Failed to extract username claim from token!"; LOG.error(errorMsg); throw new JwtAuthenticationException(errorMsg, e); } } Claims validateTokenAndGetClaims(String token); String generateToken(JwtUser userDetails); boolean canTokenBeRefreshed(Claims claims, Date lastPasswordReset); String refreshToken(String token); String getUsernameFromTokenClaims(Claims claims); List<GrantedAuthority> getRolesFromTokenClaims(Claims claims); }
@Test public void testUsernameCanBeExtractedFromTokenClaims() throws Exception { when(claims.getSubject()).thenReturn(USERNAME); assertThat(jwtUtils.getUsernameFromTokenClaims(claims)).isEqualTo(USERNAME); verify(claims, times(1)).getSubject(); } @Test(expected = JwtAuthenticationException.class) public void testExceptionThrownIfUsernameCannotBeExtractedFromTokenClaims() throws Exception { when(claims.getSubject()).thenReturn(null); jwtUtils.getUsernameFromTokenClaims(claims); verify(claims, times(1)).getSubject(); }
BotStatusController extends AbstractRuntimeController { @PreAuthorize("hasRole('USER')") @RequestMapping(value = STATUS_RESOURCE_PATH, method = RequestMethod.GET) public ResponseEntity<?> getAllBotStatus(@AuthenticationPrincipal User user) { LOG.info("GET " + RUNTIME_ENDPOINT_BASE_URI + STATUS_RESOURCE_PATH + " - getAllBotStatus()"); final List<BotStatus> allBotStatus = botProcessService.getAllBotStatus(); return allBotStatus.isEmpty() ? new ResponseEntity<>(HttpStatus.NOT_FOUND) : buildResponseEntity(allBotStatus, HttpStatus.OK); } @Autowired BotStatusController(BotStatusService botProcessService); @PreAuthorize("hasRole('USER')") @RequestMapping(value = "/{botId}" + STATUS_RESOURCE_PATH, method = RequestMethod.GET) ResponseEntity<?> getBotStatus(@AuthenticationPrincipal User user, @PathVariable String botId); @PreAuthorize("hasRole('USER')") @RequestMapping(value = STATUS_RESOURCE_PATH, method = RequestMethod.GET) ResponseEntity<?> getAllBotStatus(@AuthenticationPrincipal User user); }
@Test public void whenGetAllBotStatusCalledWhenUserIsAuthenticatedThenExpectSuccess() throws Exception { final List<BotStatus> allBotStatus = new ArrayList<>(); allBotStatus.add(bot1Status); allBotStatus.add(bot2Status); given(botProcessService.getAllBotStatus()).willReturn(allBotStatus); mockMvc.perform(get(RUNTIME_ENDPOINT_BASE_URI + STATUS_RESOURCE_PATH) .header("Authorization", "Bearer " + getJwt(VALID_USER_NAME, VALID_USER_PASSWORD))) .andDo(print()) .andExpect(status().isOk()) .andExpect(jsonPath("$.data.[0].id").value(BOT_1_ID)) .andExpect(jsonPath("$.data.[0].name").value(BOT_1_NAME)) .andExpect(jsonPath("$.data.[0].status").value(BOT_1_STATUS)) .andExpect(jsonPath("$.data.[1].id").value(BOT_2_ID)) .andExpect(jsonPath("$.data.[1].name").value(BOT_2_NAME)) .andExpect(jsonPath("$.data.[1].status").value(BOT_2_STATUS)); verify(botProcessService, times(1)).getAllBotStatus(); }