target stringlengths 20 113k | src_fm stringlengths 11 86.3k | src_fm_fc stringlengths 21 86.4k | src_fm_fc_co stringlengths 30 86.4k | src_fm_fc_ms stringlengths 42 86.8k | src_fm_fc_ms_ff stringlengths 43 86.8k |
|---|---|---|---|---|---|
@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(ar... | @Override @Nullable public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) { return delegate.schedule(new TracedRunnable(task, tracer), trigger); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override @Nullable public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) { return delegate.schedule(new TracedRunnable(task, tracer), trigger); } } | 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); } | 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 s... | 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 s... |
@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.getVa... | @Override @Nullable public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) { return delegate.schedule(new TracedRunnable(task, tracer), trigger); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override @Nullable public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) { return delegate.schedule(new TracedRunnable(task, tracer), trigger); } } | 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); } | 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 s... | 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 s... |
@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(argument... | @Override @Nullable public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) { return delegate.schedule(new TracedRunnable(task, tracer), trigger); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override @Nullable public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) { return delegate.schedule(new TracedRunnable(task, tracer), trigger); } } | 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); } | 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 s... | 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 s... |
@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("pare... | 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... | 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) ... | 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) ... | 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) ... | 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) ... |
@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), e... | @Override public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period) { return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), startTime, period); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period) { return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), startTime, period); } } | 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, ThreadPoolTaskSch... | 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, ThreadPoolTaskSch... | 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, ThreadPoolTaskSch... |
@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); ver... | @Override public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period) { return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), startTime, period); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period) { return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), startTime, period); } } | 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, ThreadPoolTaskSch... | 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, ThreadPoolTaskSch... | 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, ThreadPoolTaskSch... |
@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.getVal... | @Override public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period) { return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), startTime, period); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period) { return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), startTime, period); } } | 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, ThreadPoolTaskSch... | 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, ThreadPoolTaskSch... | 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, ThreadPoolTaskSch... |
@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()... | @Override public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period) { return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), startTime, period); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period) { return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), startTime, period); } } | 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, ThreadPoolTaskSch... | 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, ThreadPoolTaskSch... | 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, ThreadPoolTaskSch... |
@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... | @Override public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay) { return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), startTime, delay); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay) { return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), startTime, delay); } } | 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, ThreadPoolTas... | 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, ThreadPoolTas... | 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, ThreadPoolTas... |
@Test public void scheduleWithFixedDelayWithLong() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); scheduler.scheduleWithFixedDelay(mockRunnable, 1000L); verify(delegate).scheduleWithFixedDelay(argumentCaptor.capture(), eq(1000L)); verifyTracedRunnable(argumentCapt... | @Override public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay) { return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), startTime, delay); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay) { return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), startTime, delay); } } | 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, ThreadPoolTas... | 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, ThreadPoolTas... | 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, ThreadPoolTas... |
@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... | @Override public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay) { return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), startTime, delay); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay) { return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), startTime, delay); } } | 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, ThreadPoolTas... | 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, ThreadPoolTas... | 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, ThreadPoolTas... |
@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.... | @Override public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay) { return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), startTime, delay); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay) { return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), startTime, delay); } } | 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, ThreadPoolTas... | 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, ThreadPoolTas... | 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, ThreadPoolTas... |
@Test public void setThreadFactory() { final ThreadFactory threadFactory = mock(ThreadFactory.class); scheduler.setThreadFactory(threadFactory); verify(delegate).setThreadFactory(threadFactory); } | @Override public void setThreadFactory(ThreadFactory threadFactory) { delegate.setThreadFactory(threadFactory); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadFactory(ThreadFactory threadFactory) { delegate.setThreadFactory(threadFactory); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadFactory(ThreadFactory threadFactory) { delegate.setThreadFactory(threadFactory); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadFactory(ThreadFactory threadFactory) { delegate.setThreadFactory(threadFactory); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRe... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadFactory(ThreadFactory threadFactory) { delegate.setThreadFactory(threadFactory); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRe... |
@Test public void setThreadNamePrefix() { final String threadNamePrefix = "c137"; scheduler.setThreadNamePrefix(threadNamePrefix); verify(delegate).setThreadNamePrefix(threadNamePrefix); } | @Override public void setThreadNamePrefix(String threadNamePrefix) { delegate.setThreadNamePrefix(threadNamePrefix); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadNamePrefix(String threadNamePrefix) { delegate.setThreadNamePrefix(threadNamePrefix); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadNamePrefix(String threadNamePrefix) { delegate.setThreadNamePrefix(threadNamePrefix); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadNamePrefix(String threadNamePrefix) { delegate.setThreadNamePrefix(threadNamePrefix); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void ... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadNamePrefix(String threadNamePrefix) { delegate.setThreadNamePrefix(threadNamePrefix); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void ... |
@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_TYP... | @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)... | TracingChannelInterceptor extends ChannelInterceptorAdapter implements
ExecutorChannelInterceptor { @Override public void afterMessageHandled(Message<?> message, MessageChannel channel, MessageHandler handler, Exception arg3) { if ((handler instanceof WebSocketAnnotationMethodMessageHandler || handler instanceof Su... | TracingChannelInterceptor extends ChannelInterceptorAdapter implements
ExecutorChannelInterceptor { @Override public void afterMessageHandled(Message<?> message, MessageChannel channel, MessageHandler handler, Exception arg3) { if ((handler instanceof WebSocketAnnotationMethodMessageHandler || handler instanceof Su... | TracingChannelInterceptor extends ChannelInterceptorAdapter implements
ExecutorChannelInterceptor { @Override public void afterMessageHandled(Message<?> message, MessageChannel channel, MessageHandler handler, Exception arg3) { if ((handler instanceof WebSocketAnnotationMethodMessageHandler || handler instanceof Su... | TracingChannelInterceptor extends ChannelInterceptorAdapter implements
ExecutorChannelInterceptor { @Override public void afterMessageHandled(Message<?> message, MessageChannel channel, MessageHandler handler, Exception arg3) { if ((handler instanceof WebSocketAnnotationMethodMessageHandler || handler instanceof Su... |
@Test public void setRejectedExecutionHandler() { final RejectedExecutionHandler rejectedExecutionHandler = mock(RejectedExecutionHandler.class); scheduler.setRejectedExecutionHandler(rejectedExecutionHandler); verify(delegate).setRejectedExecutionHandler(rejectedExecutionHandler); } | @Override public void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler) { delegate.setRejectedExecutionHandler(rejectedExecutionHandler); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler) { delegate.setRejectedExecutionHandler(rejectedExecutionHandler); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler) { delegate.setRejectedExecutionHandler(rejectedExecutionHandler); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler) { delegate.setRejectedExecutionHandler(rejectedExecutionHandler); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Overri... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler) { delegate.setRejectedExecutionHandler(rejectedExecutionHandler); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Overri... |
@Test public void setWaitForTasksToCompleteOnShutdown() { scheduler.setWaitForTasksToCompleteOnShutdown(true); verify(delegate).setWaitForTasksToCompleteOnShutdown(true); } | @Override public void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown) { delegate.setWaitForTasksToCompleteOnShutdown(waitForJobsToCompleteOnShutdown); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown) { delegate.setWaitForTasksToCompleteOnShutdown(waitForJobsToCompleteOnShutdown); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown) { delegate.setWaitForTasksToCompleteOnShutdown(waitForJobsToCompleteOnShutdown); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler deleg... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown) { delegate.setWaitForTasksToCompleteOnShutdown(waitForJobsToCompleteOnShutdown); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler deleg... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown) { delegate.setWaitForTasksToCompleteOnShutdown(waitForJobsToCompleteOnShutdown); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler deleg... |
@Test public void setAwaitTerminationSeconds() { scheduler.setAwaitTerminationSeconds(5); verify(delegate).setAwaitTerminationSeconds(5); } | @Override public void setAwaitTerminationSeconds(int awaitTerminationSeconds) { delegate.setAwaitTerminationSeconds(awaitTerminationSeconds); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setAwaitTerminationSeconds(int awaitTerminationSeconds) { delegate.setAwaitTerminationSeconds(awaitTerminationSeconds); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setAwaitTerminationSeconds(int awaitTerminationSeconds) { delegate.setAwaitTerminationSeconds(awaitTerminationSeconds); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setAwaitTerminationSeconds(int awaitTerminationSeconds) { delegate.setAwaitTerminationSeconds(awaitTerminationSeconds); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int p... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setAwaitTerminationSeconds(int awaitTerminationSeconds) { delegate.setAwaitTerminationSeconds(awaitTerminationSeconds); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int p... |
@Test public void setBeanName() { final String name = "gazorp"; scheduler.setBeanName(name); verify(delegate).setBeanName(name); } | @Override public void setBeanName(String name) { delegate.setBeanName(name); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setBeanName(String name) { delegate.setBeanName(name); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setBeanName(String name) { delegate.setBeanName(name); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | 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 removeOn... | 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 removeOn... |
@Test public void afterPropertiesSet() { scheduler.afterPropertiesSet(); verify(delegate).afterPropertiesSet(); } | @Override public void afterPropertiesSet() { delegate.afterPropertiesSet(); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void afterPropertiesSet() { delegate.afterPropertiesSet(); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void afterPropertiesSet() { delegate.afterPropertiesSet(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void afterPropertiesSet() { delegate.afterPropertiesSet(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnC... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void afterPropertiesSet() { delegate.afterPropertiesSet(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnC... |
@Test public void initialize() { scheduler.initialize(); verify(delegate).initialize(); } | @Override public void initialize() { delegate.initialize(); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void initialize() { delegate.initialize(); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void initialize() { delegate.initialize(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void initialize() { delegate.initialize(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @O... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void initialize() { delegate.initialize(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @O... |
@Test public void destroy() { scheduler.destroy(); verify(delegate).destroy(); } | @Override public void destroy() { delegate.destroy(); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void destroy() { delegate.destroy(); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void destroy() { delegate.destroy(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void destroy() { delegate.destroy(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Overrid... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void destroy() { delegate.destroy(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Overrid... |
@Test public void shutdown() { scheduler.shutdown(); verify(delegate).shutdown(); } | @Override public void shutdown() { delegate.shutdown(); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void shutdown() { delegate.shutdown(); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void shutdown() { delegate.shutdown(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void shutdown() { delegate.shutdown(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Overr... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void shutdown() { delegate.shutdown(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Overr... |
@Test public void newThread() { final Runnable runnable = mock(Runnable.class); scheduler.newThread(runnable); verify(delegate).newThread(runnable); } | @Override public Thread newThread(Runnable runnable) { return delegate.newThread(runnable); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public Thread newThread(Runnable runnable) { return delegate.newThread(runnable); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public Thread newThread(Runnable runnable) { return delegate.newThread(runnable); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | 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(b... | 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(b... |
@Test public void getThreadNamePrefix() { scheduler.getThreadNamePrefix(); verify(delegate).getThreadNamePrefix(); } | @Override public String getThreadNamePrefix() { return delegate.getThreadNamePrefix(); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public String getThreadNamePrefix() { return delegate.getThreadNamePrefix(); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public String getThreadNamePrefix() { return delegate.getThreadNamePrefix(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public String getThreadNamePrefix() { return delegate.getThreadNamePrefix(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolea... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public String getThreadNamePrefix() { return delegate.getThreadNamePrefix(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolea... |
@Test public void setPoolSize() { scheduler.setPoolSize(10); verify(delegate).setPoolSize(10); } | @Override public void setPoolSize(int poolSize) { delegate.setPoolSize(poolSize); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setPoolSize(int poolSize) { delegate.setPoolSize(poolSize); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setPoolSize(int poolSize) { delegate.setPoolSize(poolSize); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | 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 rem... | 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 rem... |
@Test public void setThreadPriority() { final int threadPriority = 5150; scheduler.setThreadPriority(threadPriority); verify(delegate).setThreadPriority(threadPriority); } | @Override public void setThreadPriority(int threadPriority) { delegate.setThreadPriority(threadPriority); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadPriority(int threadPriority) { delegate.setThreadPriority(threadPriority); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadPriority(int threadPriority) { delegate.setThreadPriority(threadPriority); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadPriority(int threadPriority) { delegate.setThreadPriority(threadPriority); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOn... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadPriority(int threadPriority) { delegate.setThreadPriority(threadPriority); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOn... |
@Test public void getThreadPriority() { scheduler.getThreadPriority(); verify(delegate).getThreadPriority(); } | @Override public int getThreadPriority() { return delegate.getThreadPriority(); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public int getThreadPriority() { return delegate.getThreadPriority(); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public int getThreadPriority() { return delegate.getThreadPriority(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public int getThreadPriority() { return delegate.getThreadPriority(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean remov... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public int getThreadPriority() { return delegate.getThreadPriority(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean remov... |
@Test public void setDaemon() { scheduler.setDaemon(true); verify(delegate).setDaemon(true); } | @Override public void setDaemon(boolean daemon) { delegate.setDaemon(daemon); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setDaemon(boolean daemon) { delegate.setDaemon(daemon); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setDaemon(boolean daemon) { delegate.setDaemon(daemon); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | 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 removeO... | 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 removeO... |
@Test public void isDaemon() { scheduler.isDaemon(); verify(delegate).isDaemon(); } | @Override public boolean isDaemon() { return delegate.isDaemon(); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public boolean isDaemon() { return delegate.isDaemon(); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public boolean isDaemon() { return delegate.isDaemon(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public boolean isDaemon() { return delegate.isDaemon(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolic... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public boolean isDaemon() { return delegate.isDaemon(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolic... |
@Test public void setThreadGroupName() { final String name = "crombopulous"; scheduler.setThreadGroupName(name); verify(delegate).setThreadGroupName(name); } | @Override public void setThreadGroupName(String name) { delegate.setThreadGroupName(name); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadGroupName(String name) { delegate.setThreadGroupName(name); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadGroupName(String name) { delegate.setThreadGroupName(name); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | 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(bo... | 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(bo... |
@Test public void setThreadGroup() { final ThreadGroup threadGroup = mock(ThreadGroup.class); scheduler.setThreadGroup(threadGroup); verify(delegate).setThreadGroup(threadGroup); } | @Override public void setThreadGroup(ThreadGroup threadGroup) { delegate.setThreadGroup(threadGroup); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadGroup(ThreadGroup threadGroup) { delegate.setThreadGroup(threadGroup); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadGroup(ThreadGroup threadGroup) { delegate.setThreadGroup(threadGroup); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadGroup(ThreadGroup threadGroup) { delegate.setThreadGroup(threadGroup); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCanc... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadGroup(ThreadGroup threadGroup) { delegate.setThreadGroup(threadGroup); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCanc... |
@Test public void getThreadGroup() { scheduler.getThreadGroup(); verify(delegate).getThreadGroup(); } | @Override @Nullable public ThreadGroup getThreadGroup() { return delegate.getThreadGroup(); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override @Nullable public ThreadGroup getThreadGroup() { return delegate.getThreadGroup(); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override @Nullable public ThreadGroup getThreadGroup() { return delegate.getThreadGroup(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override @Nullable public ThreadGroup getThreadGroup() { return delegate.getThreadGroup(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(b... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override @Nullable public ThreadGroup getThreadGroup() { return delegate.getThreadGroup(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(b... |
@Test public void createThread() { final Runnable runnable = mock(Runnable.class); scheduler.createThread(runnable); verify(delegate).createThread(runnable); } | @Override public Thread createThread(Runnable runnable) { return delegate.createThread(runnable); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public Thread createThread(Runnable runnable) { return delegate.createThread(runnable); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public Thread createThread(Runnable runnable) { return delegate.createThread(runnable); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | 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 setRemoveOnCancelPo... | 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 setRemoveOnCancelPo... |
@Test public void prefersShortLivedTasks() { scheduler.prefersShortLivedTasks(); verify(delegate).prefersShortLivedTasks(); } | @Override public boolean prefersShortLivedTasks() { return delegate.prefersShortLivedTasks(); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public boolean prefersShortLivedTasks() { return delegate.prefersShortLivedTasks(); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public boolean prefersShortLivedTasks() { return delegate.prefersShortLivedTasks(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public boolean prefersShortLivedTasks() { return delegate.prefersShortLivedTasks(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public boolean prefersShortLivedTasks() { return delegate.prefersShortLivedTasks(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy... |
@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); } | @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 TracedAs... | CustomAsyncConfigurerAutoConfiguration implements BeanPostProcessor, PriorityOrdered, BeanFactoryAware { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof AsyncConfigurer && !(bean instanceof TracedAsyncConfigurer)) { AsyncConfigurer configu... | CustomAsyncConfigurerAutoConfiguration implements BeanPostProcessor, PriorityOrdered, BeanFactoryAware { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof AsyncConfigurer && !(bean instanceof TracedAsyncConfigurer)) { AsyncConfigurer configu... | CustomAsyncConfigurerAutoConfiguration implements BeanPostProcessor, PriorityOrdered, BeanFactoryAware { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof AsyncConfigurer && !(bean instanceof TracedAsyncConfigurer)) { AsyncConfigurer configu... | CustomAsyncConfigurerAutoConfiguration implements BeanPostProcessor, PriorityOrdered, BeanFactoryAware { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof AsyncConfigurer && !(bean instanceof TracedAsyncConfigurer)) { AsyncConfigurer configu... |
@Test public void setRemoveOnCancelPolicy() { scheduler.setRemoveOnCancelPolicy(true); verify(delegate).setRemoveOnCancelPolicy(true); } | @Override public void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy) { delegate.setRemoveOnCancelPolicy(removeOnCancelPolicy); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy) { delegate.setRemoveOnCancelPolicy(removeOnCancelPolicy); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy) { delegate.setRemoveOnCancelPolicy(removeOnCancelPolicy); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy) { delegate.setRemoveOnCancelPolicy(removeOnCancelPolicy); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize)... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy) { delegate.setRemoveOnCancelPolicy(removeOnCancelPolicy); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize)... |
@Test public void testNonMongoClientBeansAreReturnedUnaltered() { final Object expected = new Object(); final Object actual = processor.postProcessAfterInitialization(expected, "any-bean-name"); assertThat(actual).isSameAs(expected); } | @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... | 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 TracingCommandListe... | 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 TracingCommandListe... | 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 TracingCommandListe... | 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 TracingCommandListe... |
@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); } | @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... | 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 TracingCommandListe... | 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 TracingCommandListe... | 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 TracingCommandListe... | 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 TracingCommandListe... |
@Test public void testTracingMongoClientBeanNotWrapped() { final Object actual = processor.postProcessAfterInitialization(tracingClient, "any-bean-name"); assertThat(actual).isSameAs(tracingClient); } | @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... | 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 TracingCommandListe... | 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 TracingCommandListe... | 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 TracingCommandListe... | 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 TracingCommandListe... |
@Test public void setErrorHandler() { final ErrorHandler errorHandler = mock(ErrorHandler.class); scheduler.setErrorHandler(errorHandler); verify(delegate).setErrorHandler(errorHandler); } | @Override public void setErrorHandler(ErrorHandler errorHandler) { delegate.setErrorHandler(errorHandler); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setErrorHandler(ErrorHandler errorHandler) { delegate.setErrorHandler(errorHandler); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setErrorHandler(ErrorHandler errorHandler) { delegate.setErrorHandler(errorHandler); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setErrorHandler(ErrorHandler errorHandler) { delegate.setErrorHandler(errorHandler); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveO... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setErrorHandler(ErrorHandler errorHandler) { delegate.setErrorHandler(errorHandler); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveO... |
@Test public void getScheduledExecutor() { scheduler.getScheduledExecutor(); verify(delegate).getScheduledExecutor(); } | @Override public ScheduledExecutorService getScheduledExecutor() throws IllegalStateException { return delegate.getScheduledExecutor(); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledExecutorService getScheduledExecutor() throws IllegalStateException { return delegate.getScheduledExecutor(); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledExecutorService getScheduledExecutor() throws IllegalStateException { return delegate.getScheduledExecutor(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledExecutorService getScheduledExecutor() throws IllegalStateException { return delegate.getScheduledExecutor(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSiz... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledExecutorService getScheduledExecutor() throws IllegalStateException { return delegate.getScheduledExecutor(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSiz... |
@Test public void getScheduledThreadPoolExecutor() { scheduler.getScheduledThreadPoolExecutor(); verify(delegate).getScheduledThreadPoolExecutor(); } | @Override public ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor() throws IllegalStateException { return delegate.getScheduledThreadPoolExecutor(); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor() throws IllegalStateException { return delegate.getScheduledThreadPoolExecutor(); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor() throws IllegalStateException { return delegate.getScheduledThreadPoolExecutor(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor() throws IllegalStateException { return delegate.getScheduledThreadPoolExecutor(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void ... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor() throws IllegalStateException { return delegate.getScheduledThreadPoolExecutor(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void ... |
@Test public void getPoolSize() { scheduler.getPoolSize(); verify(delegate).getPoolSize(); } | @Override public int getPoolSize() { return delegate.getPoolSize(); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public int getPoolSize() { return delegate.getPoolSize(); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public int getPoolSize() { return delegate.getPoolSize(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public int getPoolSize() { return delegate.getPoolSize(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPol... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public int getPoolSize() { return delegate.getPoolSize(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPol... |
@Test public void isRemoveOnCancelPolicy() { scheduler.isRemoveOnCancelPolicy(); verify(delegate).isRemoveOnCancelPolicy(); } | @Override public boolean isRemoveOnCancelPolicy() { return delegate.isRemoveOnCancelPolicy(); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public boolean isRemoveOnCancelPolicy() { return delegate.isRemoveOnCancelPolicy(); } } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public boolean isRemoveOnCancelPolicy() { return delegate.isRemoveOnCancelPolicy(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); } | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public boolean isRemoveOnCancelPolicy() { return delegate.isRemoveOnCancelPolicy(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy... | TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public boolean isRemoveOnCancelPolicy() { return delegate.isRemoveOnCancelPolicy(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy... |
@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!";... | public static Props props() { return Props.create(LargeMessageProxy.class); } | LargeMessageProxy extends AbstractLoggingActor { public static Props props() { return Props.create(LargeMessageProxy.class); } } | LargeMessageProxy extends AbstractLoggingActor { public static Props props() { return Props.create(LargeMessageProxy.class); } } | LargeMessageProxy extends AbstractLoggingActor { public static Props props() { return Props.create(LargeMessageProxy.class); } static Props props(); @Override Receive createReceive(); } | 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 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... | public static Props props() { return Props.create(LargeMessageProxy.class); } | LargeMessageProxy extends AbstractLoggingActor { public static Props props() { return Props.create(LargeMessageProxy.class); } } | LargeMessageProxy extends AbstractLoggingActor { public static Props props() { return Props.create(LargeMessageProxy.class); } } | LargeMessageProxy extends AbstractLoggingActor { public static Props props() { return Props.create(LargeMessageProxy.class); } static Props props(); @Override Receive createReceive(); } | 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 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(Du... | public static Props props() { return Props.create(Worker.class); } | Worker extends AbstractLoggingActor { public static Props props() { return Props.create(Worker.class); } } | Worker extends AbstractLoggingActor { public static Props props() { return Props.create(Worker.class); } } | Worker extends AbstractLoggingActor { public static Props props() { return Props.create(Worker.class); } static Props props(); @Override void preStart(); @Override void postStop(); @Override Receive createReceive(); } | 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 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... | public static Props props() { return Props.create(Worker.class); } | Worker extends AbstractLoggingActor { public static Props props() { return Props.create(Worker.class); } } | Worker extends AbstractLoggingActor { public static Props props() { return Props.create(Worker.class); } } | Worker extends AbstractLoggingActor { public static Props props() { return Props.create(Worker.class); } static Props props(); @Override void preStart(); @Override void postStop(); @Override Receive createReceive(); } | 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 getUser() { User userEntity = new User("john.doe@gmail.com", "John", "Doe"); com.jonathanpetitfrere.mvvm.repository.api.model.User userModel = mapper.toModel(userEntity); when(transformers.applySchedulersToFlowable()).thenReturn(flowable -> flowable); when(userDao.loadUser(anyString())).thenReturn(Flo... | 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) .... | 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(ma... | 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(ma... | 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(ma... | 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(ma... |
@Test public void getUsers() { User userEntityOne = new User("john.doe@gmail.com", "John", "Doe"); User userEntityTwo = new User("jane.doe@gmail.com", "Jane", "Doe"); List<User> userEntities = new ArrayList<>(); List<com.jonathanpetitfrere.mvvm.repository.api.model.User> userModels = new ArrayList<>(); userEntities.add... | 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... | 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()) .flatMapIterab... | 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()) .flatMapIterab... | 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()) .flatMapIterab... | 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()) .flatMapIterab... |
@Test public void saveUserSuccess() { User userEntity = new User("john.doe@gmail.com", "John", "Doe"); when(transformers.applySchedulersToCompletable()).thenReturn(completable -> completable); Observer<Boolean> observer = mock(Observer.class); userRepository.saveUser(userEntity) .observeForever(observer); verify(userDa... | 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); }... | 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.s... | 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.s... | 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.s... | 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.s... |
@Test public void saveUserFail() { User userEntity = new User("john.doe@gmail.com", "John", "Doe"); when(transformers.applySchedulersToCompletable()).thenReturn(completable -> completable); doThrow(Exception.class).when(userDao).saveUser(any()); Observer<Boolean> observer = mock(Observer.class); userRepository.saveUser... | 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); }... | 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.s... | 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.s... | 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.s... | 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.s... |
@Test public void toModel() { User userEntity = new User("test@gmail.com", "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()... | public User toModel(com.jonathanpetitfrere.mvvm.repository.persistence.entity.User userEntity) { return new User(userEntity.getEmail(), userEntity.getFirstName(), userEntity.getLastName()); } | UserMapper { public User toModel(com.jonathanpetitfrere.mvvm.repository.persistence.entity.User userEntity) { return new User(userEntity.getEmail(), userEntity.getFirstName(), userEntity.getLastName()); } } | UserMapper { public User toModel(com.jonathanpetitfrere.mvvm.repository.persistence.entity.User userEntity) { return new User(userEntity.getEmail(), userEntity.getFirstName(), userEntity.getLastName()); } @Inject UserMapper(); } | 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... | 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... |
@Test public void toEntity() { com.jonathanpetitfrere.mvvm.repository.api.model.User userModel = new com.jonathanpetitfrere.mvvm.repository.api.model.User("test@gmail.com", "First Name", "Last Name"); User userEntity = mapper.toEntity(userModel); assertEquals(userModel.getEmail(), userEntity.getEmail()); assertEquals(u... | 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()); } | 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()); } } | 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(); } | 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.m... | 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.m... |
@Test public void unsubscribingScheduledWorksReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingAction()); worker.unsubscribe(); assertIdle(1); } | @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 Subsc... | 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(... | 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(... | 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(... | 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(... |
@Test public void unsubscribingScheduledWorkWhileRunningWorkReportsBusy() { final Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new Action0() { @Override public void call() { worker.unsubscribe(); assertBusy(); } }); delegate.triggerActions(); } | @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 Subsc... | 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(... | 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(... | 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(... | 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(... |
@Test public void scheduleWorkAfterUnsubscribedReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.unsubscribe(); worker.schedule(new CountingAction()); assertIdle(0); } | @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 Subsc... | 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(... | 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(... | 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(... | 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(... |
@Test public void finishingWorkWithoutRegisteredCallbackDoesNotCrash() { IdlingResourceScheduler scheduler = RxIdler.wrap(delegate, "Bob"); Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingAction()); delegate.triggerActions(); } | @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 Subsc... | 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(... | 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(... | 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(... | 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(... |
@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()); } } | @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 Delegati... | 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 ne... | 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 ne... | 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 ne... | 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 ne... |
@Test public void name() { assertEquals("Bob", scheduler.getName()); } | @Override public String getName() { return name; } | DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public String getName() { return name; } } | DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public String getName() { return name; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); } | 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); ... | 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); ... |
@Test public void creatingWorkerReportsIdle() { assertIdle(0); scheduler.createWorker(); assertIdle(0); } | @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.dispos... | 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... | 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... | 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... | 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... |
@Test public void scheduledWorkReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable()); assertBusy(); } | @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.dispos... | 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... | 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... | 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... | 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... |
@Test public void scheduledWorkUnsubscribedReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable()).dispose(); assertIdle(1); } | @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.dispos... | 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... | 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... | 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... | 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... |
@Test public void scheduleWithZeroDelayReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable(), 0, SECONDS); assertBusy(); } | @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.dispos... | 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... | 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... | 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... | 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... |
@Test public void creatingWorkerReportsIdle() { assertIdle(0); scheduler.createWorker(); assertIdle(0); } | @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 Subsc... | 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(... | 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(... | 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(... | 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(... |
@Test public void scheduleWithNonZeroDelayReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable(), 1, SECONDS); assertIdle(0); } | @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.dispos... | 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... | 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... | 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... | 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... |
@Test public void schedulePeriodicallyWithZeroDelayReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedulePeriodically(new CountingRunnable(), 0, 1, SECONDS); assertBusy(); } | @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.dispos... | 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... | 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... | 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... | 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... |
@Test public void schedulePeriodicallyWithNonZeroDelayReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedulePeriodically(new CountingRunnable(), 1, 1, SECONDS); assertIdle(0); } | @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.dispos... | 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... | 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... | 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... | 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... |
@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); asser... | @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.dispos... | 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... | 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... | 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... | 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... |
@Test public void runningWorkReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new Runnable() { @Override public void run() { assertBusy(); } }); delegate.triggerActions(); } | @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.dispos... | 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... | 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... | 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... | 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... |
@Test public void unsubscribingScheduledWorksReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable()); worker.dispose(); assertIdle(1); } | @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.dispos... | 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... | 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... | 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... | 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... |
@Test public void unsubscribingScheduledWorkWhileRunningWorkReportsBusy() { final Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new Runnable() { @Override public void run() { worker.dispose(); assertBusy(); } }); delegate.triggerActions(); } | @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.dispos... | 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... | 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... | 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... | 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... |
@Test public void scheduleWorkAfterUnsubscribedReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.dispose(); worker.schedule(new CountingRunnable()); assertIdle(0); } | @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.dispos... | 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... | 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... | 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... | 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... |
@Test public void finishingWorkWithoutRegisteredCallbackDoesNotCrash() { IdlingResourceScheduler scheduler = Rx2Idler.wrap(delegate, "Bob"); Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable()); delegate.triggerActions(); } | @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.dispos... | 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... | 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... | 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... | 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... |
@Test public void createNullArgumentsFlow() { try { Rx2Idler.create(null); fail(); } catch (NullPointerException e) { assertEquals("name == null", e.getMessage()); } } | @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<Sc... | 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(... | 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(... | 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(... | 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(... |
@Test public void scheduledWorkReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingAction()); assertBusy(); } | @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 Subsc... | 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(... | 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(... | 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(... | 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(... |
@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()); } } | @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 Delegati... | 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 n... | 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 n... | 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 n... | 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 n... |
@Test public void creatingWorkerReportsIdle() { assertIdle(0); scheduler.createWorker(); assertIdle(0); } | @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.dispose... | 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... | 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... | 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... | 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... |
@Test public void scheduledWorkReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable()); assertBusy(); } | @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.dispose... | 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... | 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... | 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... | 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... |
@Test public void scheduledWorkUnsubscribedReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable()).dispose(); assertIdle(1); } | @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.dispose... | 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... | 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... | 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... | 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... |
@Test public void scheduleWithZeroDelayReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable(), 0, SECONDS); assertBusy(); } | @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.dispose... | 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... | 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... | 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... | 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... |
@Test public void scheduleWithNonZeroDelayReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable(), 1, SECONDS); assertIdle(0); } | @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.dispose... | 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... | 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... | 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... | 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... |
@Test public void schedulePeriodicallyWithZeroDelayReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedulePeriodically(new CountingRunnable(), 0, 1, SECONDS); assertBusy(); } | @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.dispose... | 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... | 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... | 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... | 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... |
@Test public void schedulePeriodicallyWithNonZeroDelayReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedulePeriodically(new CountingRunnable(), 1, 1, SECONDS); assertIdle(0); } | @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.dispose... | 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... | 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... | 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... | 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... |
@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); asser... | @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.dispose... | 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... | 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... | 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... | 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... |
@Test public void scheduledWorkUnsubscribedReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingAction()).unsubscribe(); assertIdle(1); } | @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 Subsc... | 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(... | 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(... | 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(... | 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(... |
@Test public void runningWorkReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(this::assertBusy); delegate.triggerActions(); } | @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.dispose... | 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... | 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... | 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... | 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... |
@Test public void unsubscribingScheduledWorksReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable()); worker.dispose(); assertIdle(1); } | @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.dispose... | 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... | 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... | 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... | 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... |
@Test public void unsubscribingScheduledWorkWhileRunningWorkReportsBusy() { final Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(() -> { worker.dispose(); assertBusy(); }); delegate.triggerActions(); } | @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.dispose... | 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... | 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... | 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... | 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... |
@Test public void scheduleWorkAfterUnsubscribedReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.dispose(); worker.schedule(new CountingRunnable()); assertIdle(0); } | @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.dispose... | 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... | 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... | 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... | 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... |
@Test public void finishingWorkWithoutRegisteredCallbackDoesNotCrash() { IdlingResourceScheduler scheduler = Rx3Idler.wrap(delegate, "Bob"); Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingRunnable()); delegate.triggerActions(); } | @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.dispose... | 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... | 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... | 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... | 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... |
@Test public void createNullArgumentsFlow() { try { Rx3Idler.create(null); fail(); } catch (NullPointerException e) { assertEquals("name == null", e.getMessage()); } } | @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(deleg... | 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 DelegatingIdlingResourceSche... | 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 DelegatingIdlingResourceSche... | 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 DelegatingIdlingResourceSche... | 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 DelegatingIdlingResourceSche... |
@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()); } } | @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 Delegati... | 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 n... | 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 n... | 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 n... | 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 n... |
@Test public void scheduleWithZeroDelayReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingAction(), 0, SECONDS); assertBusy(); } | @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 Subsc... | 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(... | 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(... | 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(... | 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(... |
@Test public void scheduleWithNonZeroDelayReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new CountingAction(), 1, SECONDS); assertIdle(0); } | @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 Subsc... | 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(... | 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(... | 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(... | 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(... |
@Test public void schedulePeriodicallyWithZeroDelayReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedulePeriodically(new CountingAction(), 0, 1, SECONDS); assertBusy(); } | @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 Subsc... | 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(... | 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(... | 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(... | 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(... |
@Test public void schedulePeriodicallyWithNonZeroDelayReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedulePeriodically(new CountingAction(), 1, 1, SECONDS); assertIdle(0); } | @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 Subsc... | 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(... | 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(... | 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(... | 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(... |
@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); assertIdl... | @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 Subsc... | 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(... | 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(... | 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(... | 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(... |
@Test public void runningWorkReportsBusy() { Scheduler.Worker worker = scheduler.createWorker(); worker.schedule(new Action0() { @Override public void call() { assertBusy(); } }); delegate.triggerActions(); } | @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 Subsc... | 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(... | 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(... | 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(... | 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(... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.