Datasets:
jitx
/
Methods2Test_java_unit_test_code

Dataset card Data Studio Files Community
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(argumentCaptor.getValue(), mockRunnable, mockTracer); }
@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 setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override @Nullable public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) { return delegate.schedule(new TracedRunnable(task, tracer), trigger); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void scheduleWithDate() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); final Date date = mock(Date.class); scheduler.schedule(mockRunnable, date); verify(delegate).schedule(argumentCaptor.capture(), eq(date)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); }
@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 setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override @Nullable public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) { return delegate.schedule(new TracedRunnable(task, tracer), trigger); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void scheduleWithInstant() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); final Instant instant = Instant.now(); scheduler.schedule(mockRunnable, instant); verify(delegate).schedule(argumentCaptor.capture(), eq(instant)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); }
@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 setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override @Nullable public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) { return delegate.schedule(new TracedRunnable(task, tracer), trigger); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void testPreSendClientSpan() { MessageBuilder<String> messageBuilder = MessageBuilder.withPayload("Hi") .setHeader(TracingChannelInterceptor.SIMP_MESSAGE_TYPE, SimpMessageType.MESSAGE) .setHeader(TracingChannelInterceptor.SIMP_DESTINATION, TEST_DESTINATION); MockSpan parentSpan = mockTracer.buildSpan("parent").start(); TracingChannelInterceptor interceptor = new TracingChannelInterceptor(mockTracer, Tags.SPAN_KIND_CLIENT); Scope parentScope = mockTracer.scopeManager().activate(parentSpan); Message<?> processed = interceptor.preSend(messageBuilder.build(), null); parentScope.close(); parentSpan.finish(); assertTrue(processed.getHeaders().containsKey(TracingChannelInterceptor.OPENTRACING_SPAN)); MockSpan childSpan = (MockSpan) processed.getHeaders() .get(TracingChannelInterceptor.OPENTRACING_SPAN); assertEquals(parentSpan.context().spanId(), childSpan.parentId()); assertEquals(parentSpan.context().traceId(), childSpan.context().traceId()); MockSpan.MockContext context = (MockSpan.MockContext) mockTracer .extract(Format.Builtin.TEXT_MAP, new TextMapExtractAdapter(processed.getHeaders())); assertEquals(childSpan.context().traceId(), context.traceId()); assertEquals(childSpan.context().spanId(), context.spanId()); assertEquals(TEST_DESTINATION, childSpan.operationName()); assertEquals(Tags.SPAN_KIND_CLIENT, childSpan.tags().get(Tags.SPAN_KIND.getKey())); assertEquals(TracingChannelInterceptor.WEBSOCKET, childSpan.tags().get(Tags.COMPONENT.getKey())); }
private Message<?> preSendClientSpan(Message<?> message) { Span span = tracer.buildSpan((String) message.getHeaders() .getOrDefault(SIMP_DESTINATION, UNKNOWN_DESTINATION)) .withTag(Tags.SPAN_KIND.getKey(), spanKind) .withTag(Tags.COMPONENT.getKey(), WEBSOCKET) .start(); MessageBuilder<?> messageBuilder = MessageBuilder.fromMessage(message) .setHeader(OPENTRACING_SPAN, span); tracer .inject(span.context(), Format.Builtin.TEXT_MAP, new TextMapInjectAdapter(messageBuilder)); return messageBuilder.build(); }
TracingChannelInterceptor extends ChannelInterceptorAdapter implements ExecutorChannelInterceptor { private Message<?> preSendClientSpan(Message<?> message) { Span span = tracer.buildSpan((String) message.getHeaders() .getOrDefault(SIMP_DESTINATION, UNKNOWN_DESTINATION)) .withTag(Tags.SPAN_KIND.getKey(), spanKind) .withTag(Tags.COMPONENT.getKey(), WEBSOCKET) .start(); MessageBuilder<?> messageBuilder = MessageBuilder.fromMessage(message) .setHeader(OPENTRACING_SPAN, span); tracer .inject(span.context(), Format.Builtin.TEXT_MAP, new TextMapInjectAdapter(messageBuilder)); return messageBuilder.build(); } }
TracingChannelInterceptor extends ChannelInterceptorAdapter implements ExecutorChannelInterceptor { private Message<?> preSendClientSpan(Message<?> message) { Span span = tracer.buildSpan((String) message.getHeaders() .getOrDefault(SIMP_DESTINATION, UNKNOWN_DESTINATION)) .withTag(Tags.SPAN_KIND.getKey(), spanKind) .withTag(Tags.COMPONENT.getKey(), WEBSOCKET) .start(); MessageBuilder<?> messageBuilder = MessageBuilder.fromMessage(message) .setHeader(OPENTRACING_SPAN, span); tracer .inject(span.context(), Format.Builtin.TEXT_MAP, new TextMapInjectAdapter(messageBuilder)); return messageBuilder.build(); } TracingChannelInterceptor(Tracer tracer, String spanKind); }
TracingChannelInterceptor extends ChannelInterceptorAdapter implements ExecutorChannelInterceptor { private Message<?> preSendClientSpan(Message<?> message) { Span span = tracer.buildSpan((String) message.getHeaders() .getOrDefault(SIMP_DESTINATION, UNKNOWN_DESTINATION)) .withTag(Tags.SPAN_KIND.getKey(), spanKind) .withTag(Tags.COMPONENT.getKey(), WEBSOCKET) .start(); MessageBuilder<?> messageBuilder = MessageBuilder.fromMessage(message) .setHeader(OPENTRACING_SPAN, span); tracer .inject(span.context(), Format.Builtin.TEXT_MAP, new TextMapInjectAdapter(messageBuilder)); return messageBuilder.build(); } TracingChannelInterceptor(Tracer tracer, String spanKind); @Override Message<?> preSend(Message<?> message, MessageChannel channel); @Override void afterMessageHandled(Message<?> message, MessageChannel channel, MessageHandler handler, Exception arg3); @Override Message<?> beforeHandle(Message<?> message, MessageChannel channel, MessageHandler handler); }
TracingChannelInterceptor extends ChannelInterceptorAdapter implements ExecutorChannelInterceptor { private Message<?> preSendClientSpan(Message<?> message) { Span span = tracer.buildSpan((String) message.getHeaders() .getOrDefault(SIMP_DESTINATION, UNKNOWN_DESTINATION)) .withTag(Tags.SPAN_KIND.getKey(), spanKind) .withTag(Tags.COMPONENT.getKey(), WEBSOCKET) .start(); MessageBuilder<?> messageBuilder = MessageBuilder.fromMessage(message) .setHeader(OPENTRACING_SPAN, span); tracer .inject(span.context(), Format.Builtin.TEXT_MAP, new TextMapInjectAdapter(messageBuilder)); return messageBuilder.build(); } TracingChannelInterceptor(Tracer tracer, String spanKind); @Override Message<?> preSend(Message<?> message, MessageChannel channel); @Override void afterMessageHandled(Message<?> message, MessageChannel channel, MessageHandler handler, Exception arg3); @Override Message<?> beforeHandle(Message<?> message, MessageChannel channel, MessageHandler handler); }
@Test public void scheduleAtFixedRateWithDateAndLong() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); final Date date = new Date(); scheduler.scheduleAtFixedRate(mockRunnable, date, 1000L); verify(delegate).scheduleAtFixedRate(argumentCaptor.capture(), eq(date), eq(1000L)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); }
@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, ThreadPoolTaskScheduler delegate); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period) { return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), startTime, period); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period) { return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), startTime, period); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void scheduleAtFixedRateWithInstantAndDuration() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); final Instant instant = Instant.now(); final Duration duration = Duration.ofMinutes(1); scheduler.scheduleAtFixedRate(mockRunnable, instant, duration); verify(delegate).scheduleAtFixedRate(argumentCaptor.capture(), eq(instant), eq(duration)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); }
@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, ThreadPoolTaskScheduler delegate); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period) { return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), startTime, period); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period) { return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), startTime, period); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void scheduleAtFixedRateWithLong() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); scheduler.scheduleAtFixedRate(mockRunnable, 1000L); verify(delegate).scheduleAtFixedRate(argumentCaptor.capture(), eq(1000L)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); }
@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, ThreadPoolTaskScheduler delegate); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period) { return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), startTime, period); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period) { return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), startTime, period); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void scheduleAtFixedRateWithDuration() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); final Duration duration = Duration.ofMinutes(5); scheduler.scheduleAtFixedRate(mockRunnable, duration); verify(delegate).scheduleAtFixedRate(argumentCaptor.capture(), eq(duration)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); }
@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, ThreadPoolTaskScheduler delegate); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period) { return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), startTime, period); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period) { return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), startTime, period); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void scheduleWithFixedDelayWithDateAndLong() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); final Date date = new Date(); scheduler.scheduleWithFixedDelay(mockRunnable, date, 1000L); verify(delegate).scheduleWithFixedDelay(argumentCaptor.capture(), eq(date), eq(1000L)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); }
@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, ThreadPoolTaskScheduler delegate); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay) { return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), startTime, delay); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay) { return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), startTime, delay); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void scheduleWithFixedDelayWithLong() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); scheduler.scheduleWithFixedDelay(mockRunnable, 1000L); verify(delegate).scheduleWithFixedDelay(argumentCaptor.capture(), eq(1000L)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); }
@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, ThreadPoolTaskScheduler delegate); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay) { return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), startTime, delay); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay) { return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), startTime, delay); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void scheduleWithFixedDelayWithInstantAndDuration() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); final Instant instant = Instant.now(); final Duration duration = Duration.ofMinutes(1); scheduler.scheduleWithFixedDelay(mockRunnable, instant, duration); verify(delegate).scheduleWithFixedDelay(argumentCaptor.capture(), eq(instant), eq(duration)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); }
@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, ThreadPoolTaskScheduler delegate); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay) { return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), startTime, delay); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay) { return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), startTime, delay); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void scheduleWithFixedDelayWithDuration() { final ArgumentCaptor<TracedRunnable> argumentCaptor = ArgumentCaptor.forClass(TracedRunnable.class); final Duration duration = Duration.ofMinutes(5); scheduler.scheduleWithFixedDelay(mockRunnable, duration); verify(delegate).scheduleWithFixedDelay(argumentCaptor.capture(), eq(duration)); verifyTracedRunnable(argumentCaptor.getValue(), mockRunnable, mockTracer); }
@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, ThreadPoolTaskScheduler delegate); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay) { return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), startTime, delay); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay) { return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), startTime, delay); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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 setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadFactory(ThreadFactory threadFactory) { delegate.setThreadFactory(threadFactory); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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 setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadNamePrefix(String threadNamePrefix) { delegate.setThreadNamePrefix(threadNamePrefix); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void testAfterMessageHandled() { Span span = mock(Span.class); Scope scope = mock(Scope.class); MessageHandler messageHandler = mock(WebSocketAnnotationMethodMessageHandler.class); MessageBuilder<String> messageBuilder = MessageBuilder.withPayload("Hi") .setHeader(TracingChannelInterceptor.SIMP_MESSAGE_TYPE, SimpMessageType.MESSAGE) .setHeader(TracingChannelInterceptor.SIMP_DESTINATION, TEST_DESTINATION) .setHeader(TracingChannelInterceptor.OPENTRACING_SCOPE, scope) .setHeader(TracingChannelInterceptor.OPENTRACING_SPAN, span); TracingChannelInterceptor interceptor = new TracingChannelInterceptor(mockTracer, Tags.SPAN_KIND_CLIENT); interceptor.afterMessageHandled(messageBuilder.build(), null, messageHandler, null); verify(span).finish(); verify(scope).close(); }
@Override public void afterMessageHandled(Message<?> message, MessageChannel channel, MessageHandler handler, Exception arg3) { if ((handler instanceof WebSocketAnnotationMethodMessageHandler || handler instanceof SubProtocolWebSocketHandler) && SimpMessageType.MESSAGE.equals(message.getHeaders().get(SIMP_MESSAGE_TYPE))) { message.getHeaders().get(OPENTRACING_SCOPE, Scope.class).close(); message.getHeaders().get(OPENTRACING_SPAN, Span.class).finish(); } }
TracingChannelInterceptor extends ChannelInterceptorAdapter implements ExecutorChannelInterceptor { @Override public void afterMessageHandled(Message<?> message, MessageChannel channel, MessageHandler handler, Exception arg3) { if ((handler instanceof WebSocketAnnotationMethodMessageHandler || handler instanceof SubProtocolWebSocketHandler) && SimpMessageType.MESSAGE.equals(message.getHeaders().get(SIMP_MESSAGE_TYPE))) { message.getHeaders().get(OPENTRACING_SCOPE, Scope.class).close(); message.getHeaders().get(OPENTRACING_SPAN, Span.class).finish(); } } }
TracingChannelInterceptor extends ChannelInterceptorAdapter implements ExecutorChannelInterceptor { @Override public void afterMessageHandled(Message<?> message, MessageChannel channel, MessageHandler handler, Exception arg3) { if ((handler instanceof WebSocketAnnotationMethodMessageHandler || handler instanceof SubProtocolWebSocketHandler) && SimpMessageType.MESSAGE.equals(message.getHeaders().get(SIMP_MESSAGE_TYPE))) { message.getHeaders().get(OPENTRACING_SCOPE, Scope.class).close(); message.getHeaders().get(OPENTRACING_SPAN, Span.class).finish(); } } TracingChannelInterceptor(Tracer tracer, String spanKind); }
TracingChannelInterceptor extends ChannelInterceptorAdapter implements ExecutorChannelInterceptor { @Override public void afterMessageHandled(Message<?> message, MessageChannel channel, MessageHandler handler, Exception arg3) { if ((handler instanceof WebSocketAnnotationMethodMessageHandler || handler instanceof SubProtocolWebSocketHandler) && SimpMessageType.MESSAGE.equals(message.getHeaders().get(SIMP_MESSAGE_TYPE))) { message.getHeaders().get(OPENTRACING_SCOPE, Scope.class).close(); message.getHeaders().get(OPENTRACING_SPAN, Span.class).finish(); } } TracingChannelInterceptor(Tracer tracer, String spanKind); @Override Message<?> preSend(Message<?> message, MessageChannel channel); @Override void afterMessageHandled(Message<?> message, MessageChannel channel, MessageHandler handler, Exception arg3); @Override Message<?> beforeHandle(Message<?> message, MessageChannel channel, MessageHandler handler); }
TracingChannelInterceptor extends ChannelInterceptorAdapter implements ExecutorChannelInterceptor { @Override public void afterMessageHandled(Message<?> message, MessageChannel channel, MessageHandler handler, Exception arg3) { if ((handler instanceof WebSocketAnnotationMethodMessageHandler || handler instanceof SubProtocolWebSocketHandler) && SimpMessageType.MESSAGE.equals(message.getHeaders().get(SIMP_MESSAGE_TYPE))) { message.getHeaders().get(OPENTRACING_SCOPE, Scope.class).close(); message.getHeaders().get(OPENTRACING_SPAN, Span.class).finish(); } } TracingChannelInterceptor(Tracer tracer, String spanKind); @Override Message<?> preSend(Message<?> message, MessageChannel channel); @Override void afterMessageHandled(Message<?> message, MessageChannel channel, MessageHandler handler, Exception arg3); @Override Message<?> beforeHandle(Message<?> message, MessageChannel channel, MessageHandler handler); }
@Test public void 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); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler) { delegate.setRejectedExecutionHandler(rejectedExecutionHandler); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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 delegate); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown) { delegate.setWaitForTasksToCompleteOnShutdown(waitForJobsToCompleteOnShutdown); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown) { delegate.setWaitForTasksToCompleteOnShutdown(waitForJobsToCompleteOnShutdown); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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 poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setAwaitTerminationSeconds(int awaitTerminationSeconds) { delegate.setAwaitTerminationSeconds(awaitTerminationSeconds); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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 removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setBeanName(String name) { delegate.setBeanName(name); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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 removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void afterPropertiesSet() { delegate.afterPropertiesSet(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void initialize() { delegate.initialize(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void destroy() { delegate.destroy(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void shutdown() { delegate.shutdown(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public Thread newThread(Runnable runnable) { return delegate.newThread(runnable); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public String getThreadNamePrefix() { return delegate.getThreadNamePrefix(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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 removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setPoolSize(int poolSize) { delegate.setPoolSize(poolSize); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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 setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadPriority(int threadPriority) { delegate.setThreadPriority(threadPriority); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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 removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public int getThreadPriority() { return delegate.getThreadPriority(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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 removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setDaemon(boolean daemon) { delegate.setDaemon(daemon); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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 removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public boolean isDaemon() { return delegate.isDaemon(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadGroupName(String name) { delegate.setThreadGroupName(name); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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 setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setThreadGroup(ThreadGroup threadGroup) { delegate.setThreadGroup(threadGroup); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override @Nullable public ThreadGroup getThreadGroup() { return delegate.getThreadGroup(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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 setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public Thread createThread(Runnable runnable) { return delegate.createThread(runnable); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public boolean prefersShortLivedTasks() { return delegate.prefersShortLivedTasks(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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 TracedAsyncConfigurer(tracer, configurer); } return bean; }
CustomAsyncConfigurerAutoConfiguration implements BeanPostProcessor, PriorityOrdered, BeanFactoryAware { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof AsyncConfigurer && !(bean instanceof TracedAsyncConfigurer)) { AsyncConfigurer configurer = (AsyncConfigurer) bean; Tracer tracer = this.beanFactory.getBean(Tracer.class); return new TracedAsyncConfigurer(tracer, configurer); } return bean; } }
CustomAsyncConfigurerAutoConfiguration implements BeanPostProcessor, PriorityOrdered, BeanFactoryAware { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof AsyncConfigurer && !(bean instanceof TracedAsyncConfigurer)) { AsyncConfigurer configurer = (AsyncConfigurer) bean; Tracer tracer = this.beanFactory.getBean(Tracer.class); return new TracedAsyncConfigurer(tracer, configurer); } return bean; } }
CustomAsyncConfigurerAutoConfiguration implements BeanPostProcessor, PriorityOrdered, BeanFactoryAware { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof AsyncConfigurer && !(bean instanceof TracedAsyncConfigurer)) { AsyncConfigurer configurer = (AsyncConfigurer) bean; Tracer tracer = this.beanFactory.getBean(Tracer.class); return new TracedAsyncConfigurer(tracer, configurer); } return bean; } @Override Object postProcessBeforeInitialization(Object bean, String beanName); @Override Object postProcessAfterInitialization(Object bean, String beanName); @Override int getOrder(); @Override void setBeanFactory(BeanFactory beanFactory); }
CustomAsyncConfigurerAutoConfiguration implements BeanPostProcessor, PriorityOrdered, BeanFactoryAware { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof AsyncConfigurer && !(bean instanceof TracedAsyncConfigurer)) { AsyncConfigurer configurer = (AsyncConfigurer) bean; Tracer tracer = this.beanFactory.getBean(Tracer.class); return new TracedAsyncConfigurer(tracer, configurer); } return bean; } @Override Object postProcessBeforeInitialization(Object bean, String beanName); @Override Object postProcessAfterInitialization(Object bean, String beanName); @Override int getOrder(); @Override void setBeanFactory(BeanFactory beanFactory); }
@Test public void 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); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy) { delegate.setRemoveOnCancelPolicy(removeOnCancelPolicy); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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) .build(); return new TracingMongoClient(commandListener, client.getServerAddressList(), client.getCredentialsList(), client.getMongoClientOptions()); } return bean; }
TracingMongoClientPostProcessor implements BeanPostProcessor { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof MongoClient && !(bean instanceof TracingMongoClient)) { final MongoClient client = (MongoClient) bean; final TracingCommandListener commandListener = new TracingCommandListener.Builder(tracer) .build(); return new TracingMongoClient(commandListener, client.getServerAddressList(), client.getCredentialsList(), client.getMongoClientOptions()); } return bean; } }
TracingMongoClientPostProcessor implements BeanPostProcessor { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof MongoClient && !(bean instanceof TracingMongoClient)) { final MongoClient client = (MongoClient) bean; final TracingCommandListener commandListener = new TracingCommandListener.Builder(tracer) .build(); return new TracingMongoClient(commandListener, client.getServerAddressList(), client.getCredentialsList(), client.getMongoClientOptions()); } return bean; } TracingMongoClientPostProcessor(Tracer tracer); }
TracingMongoClientPostProcessor implements BeanPostProcessor { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof MongoClient && !(bean instanceof TracingMongoClient)) { final MongoClient client = (MongoClient) bean; final TracingCommandListener commandListener = new TracingCommandListener.Builder(tracer) .build(); return new TracingMongoClient(commandListener, client.getServerAddressList(), client.getCredentialsList(), client.getMongoClientOptions()); } return bean; } TracingMongoClientPostProcessor(Tracer tracer); @Override Object postProcessAfterInitialization(Object bean, String beanName); }
TracingMongoClientPostProcessor implements BeanPostProcessor { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof MongoClient && !(bean instanceof TracingMongoClient)) { final MongoClient client = (MongoClient) bean; final TracingCommandListener commandListener = new TracingCommandListener.Builder(tracer) .build(); return new TracingMongoClient(commandListener, client.getServerAddressList(), client.getCredentialsList(), client.getMongoClientOptions()); } return bean; } TracingMongoClientPostProcessor(Tracer tracer); @Override Object postProcessAfterInitialization(Object bean, String beanName); }
@Test public void 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) .build(); return new TracingMongoClient(commandListener, client.getServerAddressList(), client.getCredentialsList(), client.getMongoClientOptions()); } return bean; }
TracingMongoClientPostProcessor implements BeanPostProcessor { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof MongoClient && !(bean instanceof TracingMongoClient)) { final MongoClient client = (MongoClient) bean; final TracingCommandListener commandListener = new TracingCommandListener.Builder(tracer) .build(); return new TracingMongoClient(commandListener, client.getServerAddressList(), client.getCredentialsList(), client.getMongoClientOptions()); } return bean; } }
TracingMongoClientPostProcessor implements BeanPostProcessor { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof MongoClient && !(bean instanceof TracingMongoClient)) { final MongoClient client = (MongoClient) bean; final TracingCommandListener commandListener = new TracingCommandListener.Builder(tracer) .build(); return new TracingMongoClient(commandListener, client.getServerAddressList(), client.getCredentialsList(), client.getMongoClientOptions()); } return bean; } TracingMongoClientPostProcessor(Tracer tracer); }
TracingMongoClientPostProcessor implements BeanPostProcessor { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof MongoClient && !(bean instanceof TracingMongoClient)) { final MongoClient client = (MongoClient) bean; final TracingCommandListener commandListener = new TracingCommandListener.Builder(tracer) .build(); return new TracingMongoClient(commandListener, client.getServerAddressList(), client.getCredentialsList(), client.getMongoClientOptions()); } return bean; } TracingMongoClientPostProcessor(Tracer tracer); @Override Object postProcessAfterInitialization(Object bean, String beanName); }
TracingMongoClientPostProcessor implements BeanPostProcessor { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof MongoClient && !(bean instanceof TracingMongoClient)) { final MongoClient client = (MongoClient) bean; final TracingCommandListener commandListener = new TracingCommandListener.Builder(tracer) .build(); return new TracingMongoClient(commandListener, client.getServerAddressList(), client.getCredentialsList(), client.getMongoClientOptions()); } return bean; } TracingMongoClientPostProcessor(Tracer tracer); @Override Object postProcessAfterInitialization(Object bean, String beanName); }
@Test public void 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) .build(); return new TracingMongoClient(commandListener, client.getServerAddressList(), client.getCredentialsList(), client.getMongoClientOptions()); } return bean; }
TracingMongoClientPostProcessor implements BeanPostProcessor { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof MongoClient && !(bean instanceof TracingMongoClient)) { final MongoClient client = (MongoClient) bean; final TracingCommandListener commandListener = new TracingCommandListener.Builder(tracer) .build(); return new TracingMongoClient(commandListener, client.getServerAddressList(), client.getCredentialsList(), client.getMongoClientOptions()); } return bean; } }
TracingMongoClientPostProcessor implements BeanPostProcessor { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof MongoClient && !(bean instanceof TracingMongoClient)) { final MongoClient client = (MongoClient) bean; final TracingCommandListener commandListener = new TracingCommandListener.Builder(tracer) .build(); return new TracingMongoClient(commandListener, client.getServerAddressList(), client.getCredentialsList(), client.getMongoClientOptions()); } return bean; } TracingMongoClientPostProcessor(Tracer tracer); }
TracingMongoClientPostProcessor implements BeanPostProcessor { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof MongoClient && !(bean instanceof TracingMongoClient)) { final MongoClient client = (MongoClient) bean; final TracingCommandListener commandListener = new TracingCommandListener.Builder(tracer) .build(); return new TracingMongoClient(commandListener, client.getServerAddressList(), client.getCredentialsList(), client.getMongoClientOptions()); } return bean; } TracingMongoClientPostProcessor(Tracer tracer); @Override Object postProcessAfterInitialization(Object bean, String beanName); }
TracingMongoClientPostProcessor implements BeanPostProcessor { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof MongoClient && !(bean instanceof TracingMongoClient)) { final MongoClient client = (MongoClient) bean; final TracingCommandListener commandListener = new TracingCommandListener.Builder(tracer) .build(); return new TracingMongoClient(commandListener, client.getServerAddressList(), client.getCredentialsList(), client.getMongoClientOptions()); } return bean; } TracingMongoClientPostProcessor(Tracer tracer); @Override Object postProcessAfterInitialization(Object bean, String beanName); }
@Test public void 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 setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void setErrorHandler(ErrorHandler errorHandler) { delegate.setErrorHandler(errorHandler); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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 poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledExecutorService getScheduledExecutor() throws IllegalStateException { return delegate.getScheduledExecutor(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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 setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor() throws IllegalStateException { return delegate.getScheduledThreadPoolExecutor(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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 removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public int getPoolSize() { return delegate.getPoolSize(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void 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(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public boolean isRemoveOnCancelPolicy() { return delegate.isRemoveOnCancelPolicy(); } TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate); @Override void setPoolSize(int poolSize); @Override void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy); @Override void setErrorHandler(ErrorHandler errorHandler); @Override ScheduledExecutorService getScheduledExecutor(); @Override ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(); @Override int getPoolSize(); @Override boolean isRemoveOnCancelPolicy(); @Override int getActiveCount(); @Override void execute(Runnable task); @Override void execute(Runnable task, long startTimeout); @Override Future<?> submit(Runnable task); @Override Future<T> submit(Callable<T> task); @Override ListenableFuture<?> submitListenable(Runnable task); @Override ListenableFuture<T> submitListenable(Callable<T> task); @Override @Nullable ScheduledFuture<?> schedule(Runnable task, Trigger trigger); @Override ScheduledFuture<?> schedule(Runnable task, Date startTime); @Override ScheduledFuture<?> schedule(Runnable task, Instant startTime); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period); @Override ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay); @Override ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay); @Override void setThreadFactory(ThreadFactory threadFactory); @Override void setThreadNamePrefix(String threadNamePrefix); @Override void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler); @Override void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown); @Override void setAwaitTerminationSeconds(int awaitTerminationSeconds); @Override void setBeanName(String name); @Override void afterPropertiesSet(); @Override void initialize(); @Override void destroy(); @Override void shutdown(); @Override Thread newThread(Runnable runnable); @Override String getThreadNamePrefix(); @Override void setThreadPriority(int threadPriority); @Override int getThreadPriority(); @Override void setDaemon(boolean daemon); @Override boolean isDaemon(); @Override void setThreadGroupName(String name); @Override void setThreadGroup(ThreadGroup threadGroup); @Override @Nullable ThreadGroup getThreadGroup(); @Override Thread createThread(Runnable runnable); @Override boolean prefersShortLivedTasks(); }
@Test public void testSmallMessageSending() { new TestKit(system) { { ActorRef sender = system.actorOf(TestActor.props(this.getRef()), "sender"); ActorRef receiver = system.actorOf(TestActor.props(this.getRef()), "receiver"); within(Duration.ofSeconds(1), () -> { String shortMessage = "Hello, this is a short message!"; LargeMessageProxy.LargeMessage<String> shortStringMessage = new LargeMessageProxy.LargeMessage<String>(shortMessage, receiver); sender.tell(shortStringMessage, this.getRef()); this.expectMsg(shortMessage); assertTrue(this.getLastSender().equals(receiver)); expectNoMessage(); return null; }); } }; }
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, this is a String message with a very large payload!"); for (int i = 0; i < 1000; i++) longMessageBuffer.append("<content>"); String longMessage = longMessageBuffer.toString(); LargeMessageProxy.LargeMessage<String> longStringMessage = new LargeMessageProxy.LargeMessage<String>(longMessage, receiver); sender.tell(longStringMessage, this.getRef()); this.expectMsg(longMessage); assertTrue(this.getLastSender().equals(receiver)); expectNoMessage(); return null; }); } }; }
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(Duration.create(3, "secs"), expectedMsg); }}; }
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(Duration.create(3, "secs"), expectedMsg); }}; }
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("[email protected]", "John", "Doe"); com.jonathanpetitfrere.mvvm.repository.api.model.User userModel = mapper.toModel(userEntity); when(transformers.applySchedulersToFlowable()).thenReturn(flowable -> flowable); when(userDao.loadUser(anyString())).thenReturn(Flowable.just(userEntity)); when(userApi.getUser(anyString())).thenReturn(Flowable.just(userModel)); Observer<User> observer = mock(Observer.class); userRepository.getUser(anyString()) .observeForever(observer); verify(userDao, times(1)).loadUser(anyString()); verify(userApi, times(1)).getUser(anyString()); verify(userDao, times(1)).saveUser(userEntity); verify(observer, only()).onChanged(userEntity); }
public LiveData<User> getUser(String email) { MutableLiveData<User> liveData = new MutableLiveData<>(); userDao.loadUser(email) .compose(transformers.applySchedulersToFlowable()) .subscribe(liveData::setValue, Timber::d); userApi.getUser(email) .compose(transformers.applySchedulersToFlowable()) .map(mapper::toEntity) .subscribe(userDao::saveUser, Timber::d); return liveData; }
UserRepository { public LiveData<User> getUser(String email) { MutableLiveData<User> liveData = new MutableLiveData<>(); userDao.loadUser(email) .compose(transformers.applySchedulersToFlowable()) .subscribe(liveData::setValue, Timber::d); userApi.getUser(email) .compose(transformers.applySchedulersToFlowable()) .map(mapper::toEntity) .subscribe(userDao::saveUser, Timber::d); return liveData; } }
UserRepository { public LiveData<User> getUser(String email) { MutableLiveData<User> liveData = new MutableLiveData<>(); userDao.loadUser(email) .compose(transformers.applySchedulersToFlowable()) .subscribe(liveData::setValue, Timber::d); userApi.getUser(email) .compose(transformers.applySchedulersToFlowable()) .map(mapper::toEntity) .subscribe(userDao::saveUser, Timber::d); return liveData; } @Inject UserRepository(); }
UserRepository { public LiveData<User> getUser(String email) { MutableLiveData<User> liveData = new MutableLiveData<>(); userDao.loadUser(email) .compose(transformers.applySchedulersToFlowable()) .subscribe(liveData::setValue, Timber::d); userApi.getUser(email) .compose(transformers.applySchedulersToFlowable()) .map(mapper::toEntity) .subscribe(userDao::saveUser, Timber::d); return liveData; } @Inject UserRepository(); LiveData<User> getUser(String email); LiveData<List<User>> getUsers(); LiveData<Boolean> saveUser(User user); }
UserRepository { public LiveData<User> getUser(String email) { MutableLiveData<User> liveData = new MutableLiveData<>(); userDao.loadUser(email) .compose(transformers.applySchedulersToFlowable()) .subscribe(liveData::setValue, Timber::d); userApi.getUser(email) .compose(transformers.applySchedulersToFlowable()) .map(mapper::toEntity) .subscribe(userDao::saveUser, Timber::d); return liveData; } @Inject UserRepository(); LiveData<User> getUser(String email); LiveData<List<User>> getUsers(); LiveData<Boolean> saveUser(User user); }
@Test public void getUsers() { User userEntityOne = new User("[email protected]", "John", "Doe"); User userEntityTwo = new User("[email protected]", "Jane", "Doe"); List<User> userEntities = new ArrayList<>(); List<com.jonathanpetitfrere.mvvm.repository.api.model.User> userModels = new ArrayList<>(); userEntities.add(userEntityOne); userEntities.add(userEntityTwo); userModels.add(mapper.toModel(userEntityOne)); userModels.add(mapper.toModel(userEntityTwo)); when(transformers.applySchedulersToFlowable()).thenReturn(flowable -> flowable); when(userDao.loadUsers()).thenReturn(Flowable.just(userEntities)); when(userApi.getUsers()).thenReturn(Flowable.just(userModels)); Observer<List<User>> observer = mock(Observer.class); userRepository.getUsers() .observeForever(observer); verify(userDao, times(userEntities.size())).saveUser(any()); verify(userApi, times(1)).getUsers(); verify(observer, only()).onChanged(userEntities); }
public LiveData<List<User>> getUsers() { MutableLiveData<List<User>> liveData = new MutableLiveData<>(); userDao.loadUsers() .compose(transformers.applySchedulersToFlowable()) .subscribe(liveData::setValue, Timber::d); userApi.getUsers() .compose(transformers.applySchedulersToFlowable()) .flatMapIterable(users -> users) .map(mapper::toEntity) .subscribe(userDao::saveUser, Timber::d); return liveData; }
UserRepository { public LiveData<List<User>> getUsers() { MutableLiveData<List<User>> liveData = new MutableLiveData<>(); userDao.loadUsers() .compose(transformers.applySchedulersToFlowable()) .subscribe(liveData::setValue, Timber::d); userApi.getUsers() .compose(transformers.applySchedulersToFlowable()) .flatMapIterable(users -> users) .map(mapper::toEntity) .subscribe(userDao::saveUser, Timber::d); return liveData; } }
UserRepository { public LiveData<List<User>> getUsers() { MutableLiveData<List<User>> liveData = new MutableLiveData<>(); userDao.loadUsers() .compose(transformers.applySchedulersToFlowable()) .subscribe(liveData::setValue, Timber::d); userApi.getUsers() .compose(transformers.applySchedulersToFlowable()) .flatMapIterable(users -> users) .map(mapper::toEntity) .subscribe(userDao::saveUser, Timber::d); return liveData; } @Inject UserRepository(); }
UserRepository { public LiveData<List<User>> getUsers() { MutableLiveData<List<User>> liveData = new MutableLiveData<>(); userDao.loadUsers() .compose(transformers.applySchedulersToFlowable()) .subscribe(liveData::setValue, Timber::d); userApi.getUsers() .compose(transformers.applySchedulersToFlowable()) .flatMapIterable(users -> users) .map(mapper::toEntity) .subscribe(userDao::saveUser, Timber::d); return liveData; } @Inject UserRepository(); LiveData<User> getUser(String email); LiveData<List<User>> getUsers(); LiveData<Boolean> saveUser(User user); }
UserRepository { public LiveData<List<User>> getUsers() { MutableLiveData<List<User>> liveData = new MutableLiveData<>(); userDao.loadUsers() .compose(transformers.applySchedulersToFlowable()) .subscribe(liveData::setValue, Timber::d); userApi.getUsers() .compose(transformers.applySchedulersToFlowable()) .flatMapIterable(users -> users) .map(mapper::toEntity) .subscribe(userDao::saveUser, Timber::d); return liveData; } @Inject UserRepository(); LiveData<User> getUser(String email); LiveData<List<User>> getUsers(); LiveData<Boolean> saveUser(User user); }
@Test public void saveUserSuccess() { User userEntity = new User("[email protected]", "John", "Doe"); when(transformers.applySchedulersToCompletable()).thenReturn(completable -> completable); Observer<Boolean> observer = mock(Observer.class); userRepository.saveUser(userEntity) .observeForever(observer); verify(userDao, times(1)).saveUser(userEntity); verify(observer, only()).onChanged(true); }
public LiveData<Boolean> saveUser(User user) { MutableLiveData<Boolean> liveData = new MutableLiveData<>(); Completable.fromAction(() -> userDao.saveUser(user)) .compose(transformers.applySchedulersToCompletable()) .subscribe(() -> liveData.setValue(true), throwable -> { Timber.d(throwable); liveData.setValue(false); }); return liveData; }
UserRepository { public LiveData<Boolean> saveUser(User user) { MutableLiveData<Boolean> liveData = new MutableLiveData<>(); Completable.fromAction(() -> userDao.saveUser(user)) .compose(transformers.applySchedulersToCompletable()) .subscribe(() -> liveData.setValue(true), throwable -> { Timber.d(throwable); liveData.setValue(false); }); return liveData; } }
UserRepository { public LiveData<Boolean> saveUser(User user) { MutableLiveData<Boolean> liveData = new MutableLiveData<>(); Completable.fromAction(() -> userDao.saveUser(user)) .compose(transformers.applySchedulersToCompletable()) .subscribe(() -> liveData.setValue(true), throwable -> { Timber.d(throwable); liveData.setValue(false); }); return liveData; } @Inject UserRepository(); }
UserRepository { public LiveData<Boolean> saveUser(User user) { MutableLiveData<Boolean> liveData = new MutableLiveData<>(); Completable.fromAction(() -> userDao.saveUser(user)) .compose(transformers.applySchedulersToCompletable()) .subscribe(() -> liveData.setValue(true), throwable -> { Timber.d(throwable); liveData.setValue(false); }); return liveData; } @Inject UserRepository(); LiveData<User> getUser(String email); LiveData<List<User>> getUsers(); LiveData<Boolean> saveUser(User user); }
UserRepository { public LiveData<Boolean> saveUser(User user) { MutableLiveData<Boolean> liveData = new MutableLiveData<>(); Completable.fromAction(() -> userDao.saveUser(user)) .compose(transformers.applySchedulersToCompletable()) .subscribe(() -> liveData.setValue(true), throwable -> { Timber.d(throwable); liveData.setValue(false); }); return liveData; } @Inject UserRepository(); LiveData<User> getUser(String email); LiveData<List<User>> getUsers(); LiveData<Boolean> saveUser(User user); }
@Test public void saveUserFail() { User userEntity = new User("[email protected]", "John", "Doe"); when(transformers.applySchedulersToCompletable()).thenReturn(completable -> completable); doThrow(Exception.class).when(userDao).saveUser(any()); Observer<Boolean> observer = mock(Observer.class); userRepository.saveUser(userEntity) .observeForever(observer); verify(userDao, times(1)).saveUser(userEntity); verify(observer, only()).onChanged(false); }
public LiveData<Boolean> saveUser(User user) { MutableLiveData<Boolean> liveData = new MutableLiveData<>(); Completable.fromAction(() -> userDao.saveUser(user)) .compose(transformers.applySchedulersToCompletable()) .subscribe(() -> liveData.setValue(true), throwable -> { Timber.d(throwable); liveData.setValue(false); }); return liveData; }
UserRepository { public LiveData<Boolean> saveUser(User user) { MutableLiveData<Boolean> liveData = new MutableLiveData<>(); Completable.fromAction(() -> userDao.saveUser(user)) .compose(transformers.applySchedulersToCompletable()) .subscribe(() -> liveData.setValue(true), throwable -> { Timber.d(throwable); liveData.setValue(false); }); return liveData; } }
UserRepository { public LiveData<Boolean> saveUser(User user) { MutableLiveData<Boolean> liveData = new MutableLiveData<>(); Completable.fromAction(() -> userDao.saveUser(user)) .compose(transformers.applySchedulersToCompletable()) .subscribe(() -> liveData.setValue(true), throwable -> { Timber.d(throwable); liveData.setValue(false); }); return liveData; } @Inject UserRepository(); }
UserRepository { public LiveData<Boolean> saveUser(User user) { MutableLiveData<Boolean> liveData = new MutableLiveData<>(); Completable.fromAction(() -> userDao.saveUser(user)) .compose(transformers.applySchedulersToCompletable()) .subscribe(() -> liveData.setValue(true), throwable -> { Timber.d(throwable); liveData.setValue(false); }); return liveData; } @Inject UserRepository(); LiveData<User> getUser(String email); LiveData<List<User>> getUsers(); LiveData<Boolean> saveUser(User user); }
UserRepository { public LiveData<Boolean> saveUser(User user) { MutableLiveData<Boolean> liveData = new MutableLiveData<>(); Completable.fromAction(() -> userDao.saveUser(user)) .compose(transformers.applySchedulersToCompletable()) .subscribe(() -> liveData.setValue(true), throwable -> { Timber.d(throwable); liveData.setValue(false); }); return liveData; } @Inject UserRepository(); LiveData<User> getUser(String email); LiveData<List<User>> getUsers(); LiveData<Boolean> saveUser(User user); }
@Test public void toModel() { User userEntity = new User("[email protected]", "First Name", "Last Name"); com.jonathanpetitfrere.mvvm.repository.api.model.User userModel = mapper.toModel(userEntity); assertEquals(userEntity.getEmail(), userModel.getEmail()); assertEquals(userEntity.getFirstName(), userModel.getFirstName()); assertEquals(userEntity.getLastName(), userModel.getLastName()); }
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.jonathanpetitfrere.mvvm.repository.persistence.entity.User toEntity(User userModel); }
UserMapper { public User toModel(com.jonathanpetitfrere.mvvm.repository.persistence.entity.User userEntity) { return new User(userEntity.getEmail(), userEntity.getFirstName(), userEntity.getLastName()); } @Inject UserMapper(); User toModel(com.jonathanpetitfrere.mvvm.repository.persistence.entity.User userEntity); com.jonathanpetitfrere.mvvm.repository.persistence.entity.User toEntity(User userModel); }
@Test public void toEntity() { com.jonathanpetitfrere.mvvm.repository.api.model.User userModel = new com.jonathanpetitfrere.mvvm.repository.api.model.User("[email protected]", "First Name", "Last Name"); User userEntity = mapper.toEntity(userModel); assertEquals(userModel.getEmail(), userEntity.getEmail()); assertEquals(userModel.getFirstName(), userEntity.getFirstName()); assertEquals(userModel.getLastName(), userEntity.getLastName()); }
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.mvvm.repository.persistence.entity.User userEntity); com.jonathanpetitfrere.mvvm.repository.persistence.entity.User toEntity(User userModel); }
UserMapper { public com.jonathanpetitfrere.mvvm.repository.persistence.entity.User toEntity(User userModel) { return new com.jonathanpetitfrere.mvvm.repository.persistence.entity.User(userModel.getEmail(), userModel.getFirstName(), userModel.getLastName()); } @Inject UserMapper(); User toModel(com.jonathanpetitfrere.mvvm.repository.persistence.entity.User userEntity); com.jonathanpetitfrere.mvvm.repository.persistence.entity.User toEntity(User userModel); }
@Test public void 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 Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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 Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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 Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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 Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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 DelegatingIdlingResourceScheduler(scheduler, name); }
RxIdler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name) { if (scheduler == null) throw new NullPointerException("scheduler == null"); if (name == null) throw new NullPointerException("name == null"); return new DelegatingIdlingResourceScheduler(scheduler, name); } }
RxIdler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name) { if (scheduler == null) throw new NullPointerException("scheduler == null"); if (name == null) throw new NullPointerException("name == null"); return new DelegatingIdlingResourceScheduler(scheduler, name); } private RxIdler(); }
RxIdler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name) { if (scheduler == null) throw new NullPointerException("scheduler == null"); if (name == null) throw new NullPointerException("name == null"); return new DelegatingIdlingResourceScheduler(scheduler, name); } private RxIdler(); @CheckResult @NonNull static RxJavaSchedulersHook hooks(); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name); }
RxIdler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name) { if (scheduler == null) throw new NullPointerException("scheduler == null"); if (name == null) throw new NullPointerException("name == null"); return new DelegatingIdlingResourceScheduler(scheduler, name); } private RxIdler(); @CheckResult @NonNull static RxJavaSchedulersHook hooks(); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name); }
@Test public void 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); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public String getName() { return name; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void creatingWorkerReportsIdle() { assertIdle(0); scheduler.createWorker(); assertIdle(0); }
@Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void betweenPeriodicSchedulesReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); CountingRunnable action = new CountingRunnable(); worker.schedulePeriodically(action, 0, 1, SECONDS); delegate.triggerActions(); assertEquals(1, action.count()); delegate.advanceTimeBy(500, MILLISECONDS); assertIdle(1); delegate.advanceTimeBy(1000, MILLISECONDS); assertIdle(2); }
@Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposables.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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<Scheduler> delegate) throws Exception { IdlingResourceScheduler scheduler = new DelegatingIdlingResourceScheduler(delegate.call(), name); IdlingRegistry.getInstance().register(scheduler); return scheduler; } }; }
Rx2Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static Function<Callable<Scheduler>, Scheduler> create(@NonNull final String name) { if (name == null) throw new NullPointerException("name == null"); return new Function<Callable<Scheduler>, Scheduler>() { @Override public Scheduler apply(Callable<Scheduler> delegate) throws Exception { IdlingResourceScheduler scheduler = new DelegatingIdlingResourceScheduler(delegate.call(), name); IdlingRegistry.getInstance().register(scheduler); return scheduler; } }; } }
Rx2Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static Function<Callable<Scheduler>, Scheduler> create(@NonNull final String name) { if (name == null) throw new NullPointerException("name == null"); return new Function<Callable<Scheduler>, Scheduler>() { @Override public Scheduler apply(Callable<Scheduler> delegate) throws Exception { IdlingResourceScheduler scheduler = new DelegatingIdlingResourceScheduler(delegate.call(), name); IdlingRegistry.getInstance().register(scheduler); return scheduler; } }; } private Rx2Idler(); }
Rx2Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static Function<Callable<Scheduler>, Scheduler> create(@NonNull final String name) { if (name == null) throw new NullPointerException("name == null"); return new Function<Callable<Scheduler>, Scheduler>() { @Override public Scheduler apply(Callable<Scheduler> delegate) throws Exception { IdlingResourceScheduler scheduler = new DelegatingIdlingResourceScheduler(delegate.call(), name); IdlingRegistry.getInstance().register(scheduler); return scheduler; } }; } private Rx2Idler(); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static Function<Callable<Scheduler>, Scheduler> create(@NonNull final String name); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name); }
Rx2Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static Function<Callable<Scheduler>, Scheduler> create(@NonNull final String name) { if (name == null) throw new NullPointerException("name == null"); return new Function<Callable<Scheduler>, Scheduler>() { @Override public Scheduler apply(Callable<Scheduler> delegate) throws Exception { IdlingResourceScheduler scheduler = new DelegatingIdlingResourceScheduler(delegate.call(), name); IdlingRegistry.getInstance().register(scheduler); return scheduler; } }; } private Rx2Idler(); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static Function<Callable<Scheduler>, Scheduler> create(@NonNull final String name); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name); }
@Test public void 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 Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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 DelegatingIdlingResourceScheduler(scheduler, name); }
Rx2Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name) { if (scheduler == null) throw new NullPointerException("scheduler == null"); if (name == null) throw new NullPointerException("name == null"); return new DelegatingIdlingResourceScheduler(scheduler, name); } }
Rx2Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name) { if (scheduler == null) throw new NullPointerException("scheduler == null"); if (name == null) throw new NullPointerException("name == null"); return new DelegatingIdlingResourceScheduler(scheduler, name); } private Rx2Idler(); }
Rx2Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name) { if (scheduler == null) throw new NullPointerException("scheduler == null"); if (name == null) throw new NullPointerException("name == null"); return new DelegatingIdlingResourceScheduler(scheduler, name); } private Rx2Idler(); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static Function<Callable<Scheduler>, Scheduler> create(@NonNull final String name); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name); }
Rx2Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name) { if (scheduler == null) throw new NullPointerException("scheduler == null"); if (name == null) throw new NullPointerException("name == null"); return new DelegatingIdlingResourceScheduler(scheduler, name); } private Rx2Idler(); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static Function<Callable<Scheduler>, Scheduler> create(@NonNull final String name); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void betweenPeriodicSchedulesReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); CountingRunnable action = new CountingRunnable(); worker.schedulePeriodically(action, 0, 1, SECONDS); delegate.triggerActions(); assertEquals(1, action.count()); delegate.advanceTimeBy(500, MILLISECONDS); assertIdle(1); delegate.advanceTimeBy(1000, MILLISECONDS); assertIdle(2); }
@Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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 Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeDisposable disposables = new CompositeDisposable(delegateWorker); @Override public Disposable schedule(Runnable action) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, 0L, 0L); Disposable disposable = delegateWorker.schedule(work); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, delayTime, 0L); Disposable disposable = delegateWorker.schedule(work, delayTime, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public Disposable schedulePeriodically(Runnable action, long initialDelay, long period, TimeUnit unit) { if (disposables.isDisposed()) { return Disposable.disposed(); } ScheduledWork work = createWork(action, initialDelay, period); Disposable disposable = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); disposables.add(disposable); ScheduledWorkDisposable workDisposable = new ScheduledWorkDisposable(work, disposable); disposables.add(workDisposable); return workDisposable; } @Override public void dispose() { disposables.dispose(); } @Override public boolean isDisposed() { return disposables.isDisposed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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(delegate.get(), name); IdlingRegistry.getInstance().register(scheduler); return scheduler; }; }
Rx3Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static Function<Supplier<Scheduler>, Scheduler> create(@NonNull final String name) { if (name == null) throw new NullPointerException("name == null"); return delegate -> { IdlingResourceScheduler scheduler = new DelegatingIdlingResourceScheduler(delegate.get(), name); IdlingRegistry.getInstance().register(scheduler); return scheduler; }; } }
Rx3Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static Function<Supplier<Scheduler>, Scheduler> create(@NonNull final String name) { if (name == null) throw new NullPointerException("name == null"); return delegate -> { IdlingResourceScheduler scheduler = new DelegatingIdlingResourceScheduler(delegate.get(), name); IdlingRegistry.getInstance().register(scheduler); return scheduler; }; } private Rx3Idler(); }
Rx3Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static Function<Supplier<Scheduler>, Scheduler> create(@NonNull final String name) { if (name == null) throw new NullPointerException("name == null"); return delegate -> { IdlingResourceScheduler scheduler = new DelegatingIdlingResourceScheduler(delegate.get(), name); IdlingRegistry.getInstance().register(scheduler); return scheduler; }; } private Rx3Idler(); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static Function<Supplier<Scheduler>, Scheduler> create(@NonNull final String name); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name); }
Rx3Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static Function<Supplier<Scheduler>, Scheduler> create(@NonNull final String name) { if (name == null) throw new NullPointerException("name == null"); return delegate -> { IdlingResourceScheduler scheduler = new DelegatingIdlingResourceScheduler(delegate.get(), name); IdlingRegistry.getInstance().register(scheduler); return scheduler; }; } private Rx3Idler(); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static Function<Supplier<Scheduler>, Scheduler> create(@NonNull final String name); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name); }
@Test public void 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 DelegatingIdlingResourceScheduler(scheduler, name); }
Rx3Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name) { if (scheduler == null) throw new NullPointerException("scheduler == null"); if (name == null) throw new NullPointerException("name == null"); return new DelegatingIdlingResourceScheduler(scheduler, name); } }
Rx3Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name) { if (scheduler == null) throw new NullPointerException("scheduler == null"); if (name == null) throw new NullPointerException("name == null"); return new DelegatingIdlingResourceScheduler(scheduler, name); } private Rx3Idler(); }
Rx3Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name) { if (scheduler == null) throw new NullPointerException("scheduler == null"); if (name == null) throw new NullPointerException("name == null"); return new DelegatingIdlingResourceScheduler(scheduler, name); } private Rx3Idler(); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static Function<Supplier<Scheduler>, Scheduler> create(@NonNull final String name); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name); }
Rx3Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name) { if (scheduler == null) throw new NullPointerException("scheduler == null"); if (name == null) throw new NullPointerException("name == null"); return new DelegatingIdlingResourceScheduler(scheduler, name); } private Rx3Idler(); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static Function<Supplier<Scheduler>, Scheduler> create(@NonNull final String name); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name); }
@Test public void 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 Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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 Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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 Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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 Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void betweenPeriodicSchedulesReportsIdle() { Scheduler.Worker worker = scheduler.createWorker(); CountingAction action = new CountingAction(); worker.schedulePeriodically(action, 0, 1, SECONDS); delegate.triggerActions(); assertEquals(1, action.count()); delegate.advanceTimeBy(500, MILLISECONDS); assertIdle(1); delegate.advanceTimeBy(1000, MILLISECONDS); assertIdle(2); }
@Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
@Test public void 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 Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public Worker createWorker() { final Worker delegateWorker = delegate.createWorker(); return new Worker() { private final CompositeSubscription subscriptions = new CompositeSubscription(delegateWorker); @Override public Subscription schedule(Action0 action) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, 0L, 0L); Subscription subscription = delegateWorker.schedule(work); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, delayTime, 0L); Subscription subscription = delegateWorker.schedule(work, delayTime, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) { if (subscriptions.isUnsubscribed()) { return Subscriptions.unsubscribed(); } ScheduledWork work = createWork(action, initialDelay, period); Subscription subscription = delegateWorker.schedulePeriodically(work, initialDelay, period, unit); subscriptions.add(subscription); ScheduledWorkSubscription workSubscription = new ScheduledWorkSubscription(work, subscription); subscriptions.add(workSubscription); return workSubscription; } @Override public void unsubscribe() { subscriptions.unsubscribe(); } @Override public boolean isUnsubscribed() { return subscriptions.isUnsubscribed(); } }; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }