method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
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(); }### Answer:
@Test public void afterPropertiesSet() { scheduler.afterPropertiesSet(); verify(delegate).afterPropertiesSet(); } |
### Question:
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(); }### Answer:
@Test public void initialize() { scheduler.initialize(); verify(delegate).initialize(); } |
### Question:
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(); }### Answer:
@Test public void destroy() { scheduler.destroy(); verify(delegate).destroy(); } |
### Question:
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(); }### Answer:
@Test public void shutdown() { scheduler.shutdown(); verify(delegate).shutdown(); } |
### Question:
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(); }### Answer:
@Test public void newThread() { final Runnable runnable = mock(Runnable.class); scheduler.newThread(runnable); verify(delegate).newThread(runnable); } |
### Question:
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(); }### Answer:
@Test public void getThreadNamePrefix() { scheduler.getThreadNamePrefix(); verify(delegate).getThreadNamePrefix(); } |
### Question:
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(); }### Answer:
@Test public void setPoolSize() { scheduler.setPoolSize(10); verify(delegate).setPoolSize(10); } |
### Question:
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(); }### Answer:
@Test public void setThreadPriority() { final int threadPriority = 5150; scheduler.setThreadPriority(threadPriority); verify(delegate).setThreadPriority(threadPriority); } |
### Question:
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(); }### Answer:
@Test public void getThreadPriority() { scheduler.getThreadPriority(); verify(delegate).getThreadPriority(); } |
### Question:
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(); }### Answer:
@Test public void setDaemon() { scheduler.setDaemon(true); verify(delegate).setDaemon(true); } |
### Question:
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(); }### Answer:
@Test public void isDaemon() { scheduler.isDaemon(); verify(delegate).isDaemon(); } |
### Question:
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(); }### Answer:
@Test public void setThreadGroupName() { final String name = "crombopulous"; scheduler.setThreadGroupName(name); verify(delegate).setThreadGroupName(name); } |
### Question:
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(); }### Answer:
@Test public void setThreadGroup() { final ThreadGroup threadGroup = mock(ThreadGroup.class); scheduler.setThreadGroup(threadGroup); verify(delegate).setThreadGroup(threadGroup); } |
### Question:
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(); }### Answer:
@Test public void getThreadGroup() { scheduler.getThreadGroup(); verify(delegate).getThreadGroup(); } |
### Question:
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(); }### Answer:
@Test public void createThread() { final Runnable runnable = mock(Runnable.class); scheduler.createThread(runnable); verify(delegate).createThread(runnable); } |
### Question:
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(); }### Answer:
@Test public void prefersShortLivedTasks() { scheduler.prefersShortLivedTasks(); verify(delegate).prefersShortLivedTasks(); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@Test public void setRemoveOnCancelPolicy() { scheduler.setRemoveOnCancelPolicy(true); verify(delegate).setRemoveOnCancelPolicy(true); } |
### Question:
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); }### Answer:
@Test public void testNonMongoClientBeansAreReturnedUnaltered() { final Object expected = new Object(); final Object actual = processor.postProcessAfterInitialization(expected, "any-bean-name"); assertThat(actual).isSameAs(expected); }
@Test public void testMongoClientBeansReplacedWithTracingClient() { final MongoClient client = new MongoClient(new MongoClientURI("mongodb: final Object actual = processor.postProcessAfterInitialization(client, "any-bean-name"); assertThat(actual).isInstanceOf(TracingMongoClient.class); }
@Test public void testTracingMongoClientBeanNotWrapped() { final Object actual = processor.postProcessAfterInitialization(tracingClient, "any-bean-name"); assertThat(actual).isSameAs(tracingClient); } |
### Question:
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(); }### Answer:
@Test public void setErrorHandler() { final ErrorHandler errorHandler = mock(ErrorHandler.class); scheduler.setErrorHandler(errorHandler); verify(delegate).setErrorHandler(errorHandler); } |
### Question:
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(); }### Answer:
@Test public void getScheduledExecutor() { scheduler.getScheduledExecutor(); verify(delegate).getScheduledExecutor(); } |
### Question:
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(); }### Answer:
@Test public void getScheduledThreadPoolExecutor() { scheduler.getScheduledThreadPoolExecutor(); verify(delegate).getScheduledThreadPoolExecutor(); } |
### Question:
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(); }### Answer:
@Test public void getPoolSize() { scheduler.getPoolSize(); verify(delegate).getPoolSize(); } |
### Question:
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(); }### Answer:
@Test public void isRemoveOnCancelPolicy() { scheduler.isRemoveOnCancelPolicy(); verify(delegate).isRemoveOnCancelPolicy(); } |
### Question:
LargeMessageProxy extends AbstractLoggingActor { public static Props props() { return Props.create(LargeMessageProxy.class); } static Props props(); @Override Receive createReceive(); static final String DEFAULT_NAME; }### Answer:
@Test public void testSmallMessageSending() { new TestKit(system) { { ActorRef sender = system.actorOf(TestActor.props(this.getRef()), "sender"); ActorRef receiver = system.actorOf(TestActor.props(this.getRef()), "receiver"); within(Duration.ofSeconds(1), () -> { String shortMessage = "Hello, this is a short message!"; LargeMessageProxy.LargeMessage<String> shortStringMessage = new LargeMessageProxy.LargeMessage<String>(shortMessage, receiver); sender.tell(shortStringMessage, this.getRef()); this.expectMsg(shortMessage); assertTrue(this.getLastSender().equals(receiver)); expectNoMessage(); return null; }); } }; }
@Test public void testLargeMessageSending() { new TestKit(system) { { ActorRef sender = system.actorOf(TestActor.props(this.getRef()), "sender"); ActorRef receiver = system.actorOf(TestActor.props(this.getRef()), "receiver"); within(Duration.ofSeconds(2), () -> { StringBuffer longMessageBuffer = new StringBuffer("Hello, this is a String message with a very large payload!"); for (int i = 0; i < 1000; i++) longMessageBuffer.append("<content>"); String longMessage = longMessageBuffer.toString(); LargeMessageProxy.LargeMessage<String> longStringMessage = new LargeMessageProxy.LargeMessage<String>(longMessage, receiver); sender.tell(longStringMessage, this.getRef()); this.expectMsg(longMessage); assertTrue(this.getLastSender().equals(receiver)); expectNoMessage(); return null; }); } }; } |
### Question:
Worker extends AbstractLoggingActor { public static Props props() { return Props.create(Worker.class); } static Props props(); @Override void preStart(); @Override void postStop(); @Override Receive createReceive(); }### Answer:
@Test public void shouldFindCorrectPrimes() { new TestKit(this.actorSystem) {{ ActorRef worker = actorSystem.actorOf(Worker.props()); worker.tell(new Worker.ValidationMessage(0, 1, 10), this.getRef()); Master.PrimesMessage expectedMsg = new Master.PrimesMessage(0, Arrays.asList(2L, 3L, 5L, 7L), true); this.expectMsg(Duration.create(3, "secs"), expectedMsg); }}; }
@Test public void shouldInterpretRangeCorrectly() { new TestKit(this.actorSystem) {{ ActorRef worker = actorSystem.actorOf(Worker.props()); worker.tell(new Worker.ValidationMessage(1, 5, 11), this.getRef()); Master.PrimesMessage expectedMsg = new Master.PrimesMessage(1, Arrays.asList(5L, 7L, 11L), true); this.expectMsg(Duration.create(3, "secs"), expectedMsg); }}; } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@Test public void saveUserSuccess() { User userEntity = new User("[email protected]", "John", "Doe"); when(transformers.applySchedulersToCompletable()).thenReturn(completable -> completable); Observer<Boolean> observer = mock(Observer.class); userRepository.saveUser(userEntity) .observeForever(observer); verify(userDao, times(1)).saveUser(userEntity); verify(observer, only()).onChanged(true); }
@Test public void saveUserFail() { User userEntity = new User("[email protected]", "John", "Doe"); when(transformers.applySchedulersToCompletable()).thenReturn(completable -> completable); doThrow(Exception.class).when(userDao).saveUser(any()); Observer<Boolean> observer = mock(Observer.class); userRepository.saveUser(userEntity) .observeForever(observer); verify(userDao, times(1)).saveUser(userEntity); verify(observer, only()).onChanged(false); } |
### Question:
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); }### Answer:
@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()); } |
### Question:
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); }### Answer:
@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()); } |
### Question:
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); }### Answer:
@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()); } } |
### Question:
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(); }### Answer:
@Test public void name() { assertEquals("Bob", scheduler.getName()); } |
### Question:
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); }### Answer:
@Test public void createNullArgumentsFlow() { try { Rx2Idler.create(null); fail(); } catch (NullPointerException e) { assertEquals("name == null", e.getMessage()); } } |
### Question:
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); }### Answer:
@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()); } } |
### Question:
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); }### Answer:
@Test public void createNullArgumentsFlow() { try { Rx3Idler.create(null); fail(); } catch (NullPointerException e) { assertEquals("name == null", e.getMessage()); } } |
### Question:
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); }### Answer:
@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()); } } |
### Question:
UrlUtils { public static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2) { int lengthDifference = url1.length() - url2.length(); if (lengthDifference == 0) { return url1.equalsIgnoreCase(url2); } else if (lengthDifference == 1) { return url1.charAt(url1.length() - 1) == '/' && url1.regionMatches(true, 0, url2, 0, url2.length()); } else if (lengthDifference == -1) { return url2.charAt(url2.length() - 1) == '/' && url2.regionMatches(true, 0, url1, 0, url1.length()); } return false; } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }### Answer:
@Test public void urlsMatchExceptForTrailingSlash() throws Exception { assertTrue(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertTrue(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertTrue(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertFalse(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertFalse(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertFalse(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertFalse(UrlUtils.urlsMatchExceptForTrailingSlash("https: assertFalse(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertFalse(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertFalse(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertTrue(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertTrue(UrlUtils.urlsMatchExceptForTrailingSlash("http: assertTrue(UrlUtils.urlsMatchExceptForTrailingSlash("http: } |
### Question:
SupportUtils { public static String normalize(@NonNull String input) { String trimmedInput = input.trim(); Uri uri = Uri.parse(trimmedInput); for (final String s : SupportUtils.SUPPORTED_URLS) { if (s.equals(input)) { return input; } } if (TextUtils.isEmpty(uri.getScheme())) { uri = Uri.parse("http: } return uri.toString(); } static String normalize(@NonNull String input); static boolean isUrl(@Nullable String url); static boolean isTemplateSupportPages(String url); static String getSumoURLForTopic(final Context context, final String topic); static String getManifestoURL(); static String getPrivacyURL(); static String getYourRightsURI(); static String getAboutURI(); static void loadSupportPages(WebView webview, String url); static final String BLANK_URL; static final String FOCUS_ABOUT_URL; static final String YOUR_RIGHTS_URI; static final String PRIVACY_URL; static final String ABOUT_URI; }### Answer:
@Test public void testNormalize() { assertEquals("http: assertEquals("https: assertEquals("https: assertEquals("file: assertEquals("http: assertEquals("http: assertEquals("http: assertEquals("http: assertEquals("http: for (final String supported : SupportUtils.SUPPORTED_URLS) { assertEquals(supported, SupportUtils.normalize(supported)); } } |
### Question:
SupportUtils { public static boolean isUrl(@Nullable String url) { if (TextUtils.isEmpty(url)) { return false; } final String trimmedUrl = url.trim().toLowerCase(Locale.getDefault()); if (trimmedUrl.contains(" ")) { return false; } for (final String s : SupportUtils.SUPPORTED_URLS) { if (s.equals(trimmedUrl)) { return true; } } Uri uri = schemePattern.matcher(trimmedUrl).find() ? Uri.parse(trimmedUrl) : Uri.parse("http: final String host = TextUtils.isEmpty(uri.getHost()) ? "" : uri.getHost(); switch (uri.getScheme()) { case "http": case "https": if (!host.contains(".")) { return host.equals("localhost"); } return !host.startsWith(".") && !host.endsWith("."); case "file": return !TextUtils.isEmpty(uri.getPath()); default: return true; } } static String normalize(@NonNull String input); static boolean isUrl(@Nullable String url); static boolean isTemplateSupportPages(String url); static String getSumoURLForTopic(final Context context, final String topic); static String getManifestoURL(); static String getPrivacyURL(); static String getYourRightsURI(); static String getAboutURI(); static void loadSupportPages(WebView webview, String url); static final String BLANK_URL; static final String FOCUS_ABOUT_URL; static final String YOUR_RIGHTS_URI; static final String PRIVACY_URL; static final String ABOUT_URI; }### Answer:
@Test public void testIsUrl() { assertTrue(SupportUtils.isUrl("http: assertTrue(SupportUtils.isUrl("https: assertTrue(SupportUtils.isUrl("https: assertTrue(SupportUtils.isUrl(" https: assertTrue(SupportUtils.isUrl(" https: assertTrue(SupportUtils.isUrl("https: assertTrue(SupportUtils.isUrl("file: assertTrue(SupportUtils.isUrl("file: assertTrue(SupportUtils.isUrl("file: assertTrue(SupportUtils.isUrl("mozilla.org")); assertTrue(SupportUtils.isUrl("192.168.1.1")); assertTrue(SupportUtils.isUrl("192.168.1.1:4000")); assertTrue(SupportUtils.isUrl("192.168.1.1/a/../b")); assertTrue(SupportUtils.isUrl("http: assertTrue(SupportUtils.isUrl("http: assertTrue(SupportUtils.isUrl("http: assertTrue(SupportUtils.isUrl("localhost")); assertTrue(SupportUtils.isUrl("http: assertTrue(SupportUtils.isUrl("about:blank")); assertTrue(SupportUtils.isUrl("focusabout:")); assertFalse(SupportUtils.isUrl("Hello World")); assertFalse(SupportUtils.isUrl("Mozilla")); assertFalse(SupportUtils.isUrl("")); assertFalse(SupportUtils.isUrl(" ")); assertFalse(SupportUtils.isUrl(":")); assertFalse(SupportUtils.isUrl(".")); assertFalse(SupportUtils.isUrl("::")); assertFalse(SupportUtils.isUrl("...")); assertFalse(SupportUtils.isUrl("file: } |
### Question:
SupportUtils { public static String getSumoURLForTopic(final Context context, final String topic) { String escapedTopic; try { escapedTopic = URLEncoder.encode(topic, "UTF-8"); } catch (UnsupportedEncodingException e) { throw new IllegalStateException("utf-8 should always be available", e); } final String appVersion; try { appVersion = context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionName; } catch (PackageManager.NameNotFoundException e) { throw new IllegalStateException("Unable find package details for Focus", e); } final String osTarget = "Android"; final String langTag = Locales.getLanguageTag(Locale.getDefault()); return "https: } static String normalize(@NonNull String input); static boolean isUrl(@Nullable String url); static boolean isTemplateSupportPages(String url); static String getSumoURLForTopic(final Context context, final String topic); static String getManifestoURL(); static String getPrivacyURL(); static String getYourRightsURI(); static String getAboutURI(); static void loadSupportPages(WebView webview, String url); static final String BLANK_URL; static final String FOCUS_ABOUT_URL; static final String YOUR_RIGHTS_URI; static final String PRIVACY_URL; static final String ABOUT_URI; }### Answer:
@Test public void getSumoURLForTopic() throws Exception { final String appVersion; try { appVersion = ApplicationProvider.getApplicationContext().getPackageManager().getPackageInfo(ApplicationProvider.getApplicationContext().getPackageName(), 0).versionName; } catch (PackageManager.NameNotFoundException e) { throw new IllegalStateException("Unable find package details for Rocket", e); } Locale.setDefault(Locale.GERMANY); assertEquals("https: SupportUtils.getSumoURLForTopic(ApplicationProvider.getApplicationContext(), "foobar")); Locale.setDefault(Locale.CANADA_FRENCH); assertEquals("https: SupportUtils.getSumoURLForTopic(ApplicationProvider.getApplicationContext(), "foobar")); } |
### Question:
SupportUtils { public static String getManifestoURL() { final String langTag = Locales.getLanguageTag(Locale.getDefault()); return "https: } static String normalize(@NonNull String input); static boolean isUrl(@Nullable String url); static boolean isTemplateSupportPages(String url); static String getSumoURLForTopic(final Context context, final String topic); static String getManifestoURL(); static String getPrivacyURL(); static String getYourRightsURI(); static String getAboutURI(); static void loadSupportPages(WebView webview, String url); static final String BLANK_URL; static final String FOCUS_ABOUT_URL; static final String YOUR_RIGHTS_URI; static final String PRIVACY_URL; static final String ABOUT_URI; }### Answer:
@Test public void getManifestoURL() throws Exception { Locale.setDefault(Locale.UK); assertEquals("https: SupportUtils.getManifestoURL()); Locale.setDefault(Locale.KOREA); assertEquals("https: SupportUtils.getManifestoURL()); } |
### Question:
ColorUtils { public static int getReadableTextColor(final int backgroundColor) { final int greyValue = grayscaleFromRGB(backgroundColor); if (greyValue < 186) { return Color.WHITE; } else { return Color.BLACK; } } static int getReadableTextColor(final int backgroundColor); }### Answer:
@Test public void testGetReadableTextColor() { assertEquals(Color.BLACK, ColorUtils.getReadableTextColor(Color.WHITE)); assertEquals(Color.WHITE, ColorUtils.getReadableTextColor(Color.BLACK)); assertEquals(Color.BLACK, ColorUtils.getReadableTextColor(0xfff6f4ec)); assertEquals(Color.WHITE, ColorUtils.getReadableTextColor(0xffdb4437)); assertEquals(Color.WHITE, ColorUtils.getReadableTextColor(0xff527da3)); assertEquals(Color.BLACK, ColorUtils.getReadableTextColor(0xfff2f7fc)); assertEquals(Color.WHITE, ColorUtils.getReadableTextColor(0xfff57c00)); } |
### Question:
MimeUtils { public static boolean isText(@Nullable String type) { return !TextUtils.isEmpty(type) && textPattern.matcher(type).find(); } private MimeUtils(); static boolean isText(@Nullable String type); static boolean isImage(@Nullable String type); static boolean isAudio(@Nullable String type); static boolean isVideo(@Nullable String type); }### Answer:
@Test public void testText() { assertTrue(MimeUtils.isText("text")); assertFalse(MimeUtils.isText("text/plain/")); assertFalse(MimeUtils.isText("text/plain*")); } |
### Question:
MimeUtils { public static boolean isImage(@Nullable String type) { return !TextUtils.isEmpty(type) && imgPattern.matcher(type).find(); } private MimeUtils(); static boolean isText(@Nullable String type); static boolean isImage(@Nullable String type); static boolean isAudio(@Nullable String type); static boolean isVideo(@Nullable String type); }### Answer:
@Test public void testImage() { assertTrue(MimeUtils.isImage("image")); assertFalse(MimeUtils.isImage("image/png/")); assertFalse(MimeUtils.isImage("image/png*")); } |
### Question:
MimeUtils { public static boolean isAudio(@Nullable String type) { return !TextUtils.isEmpty(type) && audioPattern.matcher(type).find(); } private MimeUtils(); static boolean isText(@Nullable String type); static boolean isImage(@Nullable String type); static boolean isAudio(@Nullable String type); static boolean isVideo(@Nullable String type); }### Answer:
@Test public void testAudio() { assertTrue(MimeUtils.isAudio("audio")); assertFalse(MimeUtils.isAudio("audio/mp3/")); assertFalse(MimeUtils.isAudio("audio/mp3*")); } |
### Question:
MimeUtils { public static boolean isVideo(@Nullable String type) { return !TextUtils.isEmpty(type) && videoPattern.matcher(type).find(); } private MimeUtils(); static boolean isText(@Nullable String type); static boolean isImage(@Nullable String type); static boolean isAudio(@Nullable String type); static boolean isVideo(@Nullable String type); }### Answer:
@Test public void testVideo() { assertTrue(MimeUtils.isVideo("video")); assertFalse(MimeUtils.isVideo("video/mp4/")); assertFalse(MimeUtils.isVideo("video/mp4*")); } |
### Question:
UrlUtils { public static boolean isPermittedResourceProtocol(@NonNull final String scheme) { if (TextUtils.isEmpty(scheme)) { return false; } return scheme.startsWith("http") || scheme.startsWith("https") || scheme.startsWith("file") || scheme.startsWith("data"); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }### Answer:
@Test public void isPermittedResourceProtocol() { assertTrue(UrlUtils.isPermittedResourceProtocol("http")); assertTrue(UrlUtils.isPermittedResourceProtocol("https")); assertTrue(UrlUtils.isPermittedResourceProtocol("data")); assertTrue(UrlUtils.isPermittedResourceProtocol("file")); assertFalse(UrlUtils.isPermittedResourceProtocol("nielsenwebid")); } |
### Question:
TabEntity { public boolean isValid() { final boolean hasId = !TextUtils.isEmpty(this.getId()); final boolean hasUrl = !TextUtils.isEmpty(this.getUrl()); return hasId && hasUrl; } @Ignore TabEntity(String id, String parentId); TabEntity(String id, String parentId, String title, String url); @NonNull String getId(); void setId(@NonNull String id); String getParentId(); void setParentId(String parentId); String getTitle(); void setTitle(String title); String getUrl(); void setUrl(String url); boolean isValid(); @Override String toString(); }### Answer:
@Test public void testSanity() { Assert.assertFalse(new TabEntity(null, null).isValid()); Assert.assertFalse(new TabEntity(null, null, "title", "").isValid()); Assert.assertFalse(new TabEntity(null, null, null, "url").isValid()); Assert.assertFalse(new TabEntity("id", null, null, null).isValid()); Assert.assertTrue(new TabEntity("id", null, null, "url").isValid()); Assert.assertTrue(new TabEntity("id", null, "title", "url").isValid()); } |
### Question:
BrowsingSession { public static synchronized BrowsingSession getInstance() { if (instance == null) { instance = new BrowsingSession(); } return instance; } private BrowsingSession(); static synchronized BrowsingSession getInstance(); void countBlockedTracker(); void setBlockedTrackerCount(int count); void resetTrackerCount(); LiveData<Integer> getBlockedTrackerCount(); }### Answer:
@Test public void testSingleton() { assertNotNull(BrowsingSession.getInstance()); assertEquals(BrowsingSession.getInstance(), BrowsingSession.getInstance()); } |
### Question:
SearchEngineParser { public static SearchEngine load(AssetManager assetManager, String identifier, String path) throws IOException { try (final InputStream stream = assetManager.open(path)) { return load(identifier, stream); } catch (XmlPullParserException e) { throw new AssertionError("Parser exception while reading " + path, e); } } static SearchEngine load(AssetManager assetManager, String identifier, String path); }### Answer:
@Test public void testParser() throws Exception { final InputStream stream = new FileInputStream(searchPluginPath); final SearchEngine searchEngine = SearchEngineParser.load(searchEngineIdentifier, stream); assertEquals(searchEngineIdentifier, searchEngine.getIdentifier()); assertNotNull(searchEngine.getName()); assertFalse(TextUtils.isEmpty(searchEngine.getName())); assertNotNull(searchEngine.getIcon()); final String searchTerm = UUID.randomUUID().toString(); final String searchUrl = searchEngine.buildSearchUrl(searchTerm); assertNotNull(searchUrl); assertFalse(TextUtils.isEmpty(searchUrl)); assertTrue(searchUrl.contains(searchTerm)); stream.close(); } |
### Question:
Trie { public Trie findNode(final FocusString string) { if (terminator) { if (string.length() == 0 || string.charAt(0) == '.') { return this; } } else if (string.length() == 0) { return null; } final Trie next = children.get(string.charAt(0)); if (next == null) { return null; } return next.findNode(string.substring(1)); } private Trie(char character, Trie parent); Trie findNode(final FocusString string); Trie put(final FocusString string); Trie put(char character); static Trie createRootNode(); final SparseArray<Trie> children; public boolean terminator; }### Answer:
@Test public void findNode() throws Exception { final Trie trie = Trie.createRootNode(); assertNull(trie.findNode(FocusString.create("hello"))); final Trie putNode = trie.put(FocusString.create("hello")); final Trie foundNode = trie.findNode(FocusString.create("hello")); assertNotNull(putNode); assertNotNull(foundNode); assertEquals(putNode, foundNode); assertNull(trie.findNode(FocusString.create("hell"))); assertNull(trie.findNode(FocusString.create("hellop"))); trie.put(FocusString.create("hellohello")); assertNotNull(trie.findNode(FocusString.create("hello"))); assertNotNull(trie.findNode(FocusString.create("hellohello"))); assertNull(trie.findNode(FocusString.create("hell"))); assertNull(trie.findNode(FocusString.create("hellop"))); trie.put(FocusString.create("foo.com").reverse()); assertNotNull(trie.findNode(FocusString.create("foo.com").reverse())); assertNotNull(trie.findNode(FocusString.create("bar.foo.com").reverse())); assertNull(trie.findNode(FocusString.create("bar-foo.com").reverse())); assertNull(trie.findNode(FocusString.create("oo.com").reverse())); } |
### Question:
TrackingProtectionWebViewClient extends WebViewClient { @Override public WebResourceResponse shouldInterceptRequest(final WebView view, final WebResourceRequest request) { if (!blockingEnabled) { return super.shouldInterceptRequest(view, request); } final Uri resourceUri = request.getUrl(); final String scheme = resourceUri.getScheme(); if (!request.isForMainFrame() && !scheme.equals("http") && !scheme.equals("https") && !scheme.equals("blob")) { return new WebResourceResponse(null, null, null); } final UrlMatcher matcher = getMatcher(view.getContext()); if ((currentPageURL != null && !request.isForMainFrame()) && matcher.matches(resourceUri, Uri.parse(currentPageURL))) { BrowsingSession.getInstance().countBlockedTracker(); return new WebResourceResponse(null, null, null); } return super.shouldInterceptRequest(view, request); } TrackingProtectionWebViewClient(final Context context); static void triggerPreload(final Context context); void setBlockingEnabled(boolean enabled); boolean isBlockingEnabled(); @Override WebResourceResponse shouldInterceptRequest(final WebView view, final WebResourceRequest request); void notifyCurrentURL(final String url); @Override void onPageStarted(WebView view, String url, Bitmap favicon); @Override void onReceivedHttpAuthRequest(WebView view, HttpAuthHandler handler, String host, String realm); }### Answer:
@Test public void shouldInterceptRequest() throws Exception { trackingProtectionWebViewClient.notifyCurrentURL("http: { final WebResourceRequest request = createRequest("http: final WebResourceResponse response = trackingProtectionWebViewClient.shouldInterceptRequest(webView, request); assertResourceAllowed(response); } { final WebResourceRequest request = createRequest("http: final WebResourceResponse response = trackingProtectionWebViewClient.shouldInterceptRequest(webView, request); assertResourceBlocked(response); } } |
### Question:
WebViewProvider { @VisibleForTesting static String getUABrowserString(final String existingUAString, final String focusToken) { int start = existingUAString.indexOf("AppleWebKit"); if (start == -1) { start = existingUAString.indexOf(")") + 2; if (start >= existingUAString.length()) { return focusToken; } } final String[] tokens = existingUAString.substring(start).split(" "); for (int i = 0; i < tokens.length; i++) { if (tokens[i].startsWith("Chrome")) { tokens[i] = focusToken + " " + tokens[i]; return TextUtils.join(" ", tokens); } } return TextUtils.join(" ", tokens) + " " + focusToken; } static void preload(final Context context); static View create(final Context context, final AttributeSet attrs); static View create(final Context context,
final AttributeSet attrs,
final WebSettingsHook hook); static View createDefaultWebView(Context context, AttributeSet attrs); static void applyJavaScriptSettings(Context context, WebSettings settings); static void applyAppSettings(Context context, WebSettings settings); static void applyMultiTabSettings(Context context, WebSettings settings); static String getUserAgentString(Context context); }### Answer:
@Test public void testGetUABrowserString() { String focusToken = "Focus/1.0"; final String existing = "Mozilla/5.0 (Linux; Android 5.0.2; Android SDK built for x86_64 Build/LSY66K) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/37.0.0.0 Mobile Safari/537.36"; assertEquals("AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 " + focusToken + " Chrome/37.0.0.0 Mobile Safari/537.36", WebViewProvider.getUABrowserString(existing, focusToken)); focusToken = "Klar/2.0"; assertEquals("AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 " + focusToken + " Chrome/37.0.0.0 Mobile Safari/537.36", WebViewProvider.getUABrowserString(existing, focusToken)); focusToken = "Focus/1.0"; final String imaginaryKit = "Mozilla/5.0 (Linux) ImaginaryKit/-10 (KHTML, like Gecko) Version/4.0 Chrome/37.0.0.0 Mobile Safari/537.36"; assertEquals("ImaginaryKit/-10 (KHTML, like Gecko) Version/4.0 " + focusToken + " Chrome/37.0.0.0 Mobile Safari/537.36", WebViewProvider.getUABrowserString(imaginaryKit, focusToken)); final String chromeless = "Mozilla/5.0 (Linux; Android 5.0.2; Android SDK built for x86_64 Build/LSY66K) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Imaginary/37.0.0.0 Mobile Safari/537.36"; assertEquals("AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Imaginary/37.0.0.0 Mobile Safari/537.36 " + focusToken, WebViewProvider.getUABrowserString(chromeless, focusToken)); final String chromelessImaginaryKit = "Mozilla/5.0 (Linux) ImaginaryKit/-10 (KHTML, like Gecko) Version/4.0 Imaginary/37.0.0.0 Mobile Safari/537.36"; assertEquals("ImaginaryKit/-10 (KHTML, like Gecko) Version/4.0 Imaginary/37.0.0.0 Mobile Safari/537.36 " + focusToken, WebViewProvider.getUABrowserString(chromelessImaginaryKit, focusToken)); } |
### Question:
DiskLruCache implements Closeable { public synchronized void close() throws IOException { if (journalWriter == null) { return; } for (Entry entry : new ArrayList<Entry>(lruEntries.values())) { if (entry.currentEditor != null) { entry.currentEditor.abort(); } } trimToSize(); journalWriter.close(); journalWriter = null; } private DiskLruCache(File directory, int appVersion, int valueCount, long maxSize); static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize); synchronized Value get(String key); Editor edit(String key); File getDirectory(); synchronized long getMaxSize(); synchronized void setMaxSize(long maxSize); synchronized long size(); synchronized boolean remove(String key); synchronized boolean isClosed(); synchronized void flush(); synchronized void close(); void delete(); }### Answer:
@Test public void emptyCache() throws Exception { cache.close(); assertJournalEquals(); } |
### Question:
UrlUtils { public static boolean isSupportedProtocol(@NonNull final String scheme) { if (TextUtils.isEmpty(scheme)) { return false; } return isPermittedResourceProtocol(scheme) || scheme.startsWith("error"); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }### Answer:
@Test public void isPermittedProtocol() { assertTrue(UrlUtils.isSupportedProtocol("http")); assertTrue(UrlUtils.isSupportedProtocol("https")); assertTrue(UrlUtils.isSupportedProtocol("error")); assertTrue(UrlUtils.isSupportedProtocol("data")); assertFalse(UrlUtils.isSupportedProtocol("market")); } |
### Question:
UrlUtils { public static boolean isSearchQuery(String text) { return text.contains(" "); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }### Answer:
@Test public void testIsSearchQuery() { assertTrue(UrlUtils.isSearchQuery("hello world")); assertFalse(UrlUtils.isSearchQuery("mozilla.org")); assertFalse(UrlUtils.isSearchQuery("mozilla")); } |
### Question:
UrlUtils { public static String stripUserInfo(@Nullable String url) { if (TextUtils.isEmpty(url)) { return ""; } try { URI uri = new URI(url); final String userInfo = uri.getUserInfo(); if (userInfo == null) { return url; } uri = new URI(uri.getScheme(), null, uri.getHost(), uri.getPort(), uri.getPath(), uri.getQuery(), uri.getFragment()); return uri.toString(); } catch (URISyntaxException e) { return url; } } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }### Answer:
@Test @SuppressLint("AuthLeak") public void testStripUserInfo() { assertEquals("", UrlUtils.stripUserInfo(null)); assertEquals("", UrlUtils.stripUserInfo("")); assertEquals("https: assertEquals("https: assertEquals("[email protected]", UrlUtils.stripUserInfo("[email protected]")); assertEquals("ftp: assertEquals("öäü102ß", UrlUtils.stripUserInfo("öäü102ß")); } |
### Question:
UrlUtils { public static boolean isInternalErrorURL(final String url) { return "data:text/html;charset=utf-8;base64,".equals(url); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }### Answer:
@Test public void isInternalErrorURL() { assertTrue(UrlUtils.isInternalErrorURL("data:text/html;charset=utf-8;base64,")); assertFalse(UrlUtils.isInternalErrorURL("http: assertFalse(UrlUtils.isInternalErrorURL("https: assertFalse(UrlUtils.isInternalErrorURL("www.mozilla.org")); assertFalse(UrlUtils.isInternalErrorURL("error:-8")); assertFalse(UrlUtils.isInternalErrorURL("hello world")); } |
### Question:
UrlUtils { public static boolean isHttpOrHttps(String url) { if (TextUtils.isEmpty(url)) { return false; } return url.startsWith("http:") || url.startsWith("https:"); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }### Answer:
@Test public void isHttpOrHttpsUrl() { assertFalse(UrlUtils.isHttpOrHttps(null)); assertFalse(UrlUtils.isHttpOrHttps("")); assertFalse(UrlUtils.isHttpOrHttps(" ")); assertFalse(UrlUtils.isHttpOrHttps("mozilla.org")); assertFalse(UrlUtils.isHttpOrHttps("httpstrf: assertTrue(UrlUtils.isHttpOrHttps("https: assertTrue(UrlUtils.isHttpOrHttps("http: assertTrue(UrlUtils.isHttpOrHttps("http: } |
### Question:
UrlUtils { public static String stripCommonSubdomains(@Nullable String host) { return stripPrefix(host, COMMON_SUBDOMAINS_PREFIX_ARRAY); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }### Answer:
@Test public void stripCommonSubdomains() { assertEquals(UrlUtils.stripCommonSubdomains("m.mobile.com"), "mobile.com"); assertEquals(UrlUtils.stripCommonSubdomains("mobile.mozilla.org"), "mozilla.org"); assertEquals(UrlUtils.stripCommonSubdomains("www.synology.com"), "synology.com"); assertEquals(UrlUtils.stripCommonSubdomains("i.j.k"), "i.j.k"); } |
### Question:
UrlUtils { public static String stripHttp(@Nullable String host) { return stripPrefix(host, HTTP_SCHEME_PREFIX_ARRAY); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }### Answer:
@Test public void stripHttp() { assertEquals(UrlUtils.stripHttp("http: assertEquals(UrlUtils.stripHttp("https: assertEquals(UrlUtils.stripHttp("ftp: assertEquals(UrlUtils.stripHttp("synology.com"), "synology.com"); } |
### Question:
TabUtil { public static Bundle argument(@Nullable final String parentId, boolean fromExternal, boolean toFocus) { final Bundle bundle = new Bundle(); if (!TextUtils.isEmpty(parentId)) { bundle.putString(ARG_PARENT_ID, parentId); } bundle.putBoolean(ARG_EXTERNAL, fromExternal); bundle.putBoolean(ARG_FOCUS, toFocus); return bundle; } private TabUtil(); static Bundle argument(@Nullable final String parentId,
boolean fromExternal,
boolean toFocus); @Nullable static String getParentId(@NonNull final Bundle bundle); static boolean isFromExternal(@NonNull final Bundle bundle); static boolean toFocus(@NonNull final Bundle bundle); }### Answer:
@Test public void testCreation() { Assert.assertNotNull(TabUtil.argument("parent_id", false, false)); Assert.assertNotNull(TabUtil.argument(null, false, false)); Assert.assertNotNull(TabUtil.argument(null, false, true)); Assert.assertNotNull(TabUtil.argument(null, true, false)); } |
### Question:
TaggedRuleProviderPredicate implements Predicate<RuleProvider> { @Override public boolean accept(RuleProvider provider) { Set<String> tags = provider.getMetadata().getTags(); boolean result = true; if (!includeTags.isEmpty()) { if (requireAllIncludeTags) result = tags.containsAll(includeTags); else result = CollectionUtils.containsAny(tags, includeTags); } if (result && !excludeTags.isEmpty()) { if (requireAllExcludeTags) result = !tags.containsAll(excludeTags); else result = !CollectionUtils.containsAny(tags, excludeTags); } return result; } TaggedRuleProviderPredicate(Collection<String> includeTags, Collection<String> excludeTags); TaggedRuleProviderPredicate setRequireAllIncludeTags(boolean requireAll); TaggedRuleProviderPredicate setRequireAllExcludeTags(boolean requireAll); @Override boolean accept(RuleProvider provider); @Override String toString(); }### Answer:
@Test public void testAccept() { TestTagsARules rulesA = new TestTagsARules(); TestTagsBRules rulesB = new TestTagsBRules(); TestTagsA1B1Rules rulesA1B1 = new TestTagsA1B1Rules(); Assert.assertEquals(true, isProviderAcceptedByTags(rulesA, Arrays.asList("tagA1"), false, null, false)); Assert.assertEquals(false, isProviderAcceptedByTags(rulesB, Arrays.asList("tagA1"), false, null, false)); Assert.assertEquals(true, isProviderAcceptedByTags(rulesB, Arrays.asList("tagA1", "tagB1"), false, null, false)); Assert.assertEquals(false, isProviderAcceptedByTags(rulesB, Arrays.asList("tagA1", "tagB1"), true, null, false)); Assert.assertEquals(true, isProviderAcceptedByTags(rulesB, Arrays.asList("tagA1", "tagB1", "tagC1"), false, null, false)); Assert.assertEquals(false, isProviderAcceptedByTags(rulesB, Arrays.asList("tagA1", "tagB1", "tagC1"), true, null, false)); Assert.assertEquals(true, isProviderAcceptedByTags(rulesA1B1, Arrays.asList("tagA1", "tagB1"), false, Arrays.asList("tagC1"), false)); Assert.assertEquals(false, isProviderAcceptedByTags(rulesA1B1, Arrays.asList("tagA1", "tagC1"), false, Arrays.asList("tagB1"), false)); Assert.assertEquals(false, isProviderAcceptedByTags(rulesA1B1, Arrays.asList("tagA1"), false, Arrays.asList("tagB1", "tagC1"), false)); Assert.assertEquals(true, isProviderAcceptedByTags(rulesA1B1, Arrays.asList("tagA1"), false, Arrays.asList("tagB1", "tagC1"), true)); } |
### Question:
PathUtil { public static Path getWindupUserDir() { String userHome = System.getProperty("user.home"); if (userHome == null) { Path path = new File("").toPath(); LOG.warning("$USER_HOME not set, using [" + path.toAbsolutePath().toString() + "] instead."); return path; } return Paths.get(userHome).resolve(".mta"); } static Path getWindupUserDir(); static Path getWindupHome(); static void setWindupHome(Path windupHome); static Path getUserCacheDir(); static Path getWindupCacheDir(); static Path getUserIgnoreDir(); static Path getWindupIgnoreDir(); static Path getWindupAddonsDir(); static Path getUserRulesDir(); static Path getUserLabelsDir(); static Path getWindupRulesDir(); static Path getWindupLabelsDir(); static String cleanFileName(String badFileName); static String classFilePathToClassname(String relativePath); static Path getRootFolderForSource(Path sourceFilePath, String packageName); static boolean isInSubDirectory(File dir, File file); static String pathToPackageName(String relativePath); static void createDirectory(Path dir, String dirDesc); static final String WINDUP_HOME; static final String WINDUP_RULESETS_DIR_SYSPROP; static final String WINDUP_LABELSETS_DIR_SYSPROP; static final String RULES_DIRECTORY_NAME; static final String LABELS_DIRECTORY_NAME; static final String IGNORE_DIRECTORY_NAME; static final String CACHE_DIRECTORY_NAME; static final String ADDONS_DIRECTORY_NAME; static String LIBRARY_DIRECTORY_NAME; static String BINARY_DIRECTORY_NAME; }### Answer:
@Test public void testWindupUserDir() { Assert.assertEquals(Paths.get(""), PathUtil.getWindupUserDir()); setUserHome("/foo"); Assert.assertEquals(Paths.get("/foo", ".mta"), PathUtil.getWindupUserDir()); } |
### Question:
PathUtil { public static Path getUserIgnoreDir() { return getUserSubdirectory(IGNORE_DIRECTORY_NAME); } static Path getWindupUserDir(); static Path getWindupHome(); static void setWindupHome(Path windupHome); static Path getUserCacheDir(); static Path getWindupCacheDir(); static Path getUserIgnoreDir(); static Path getWindupIgnoreDir(); static Path getWindupAddonsDir(); static Path getUserRulesDir(); static Path getUserLabelsDir(); static Path getWindupRulesDir(); static Path getWindupLabelsDir(); static String cleanFileName(String badFileName); static String classFilePathToClassname(String relativePath); static Path getRootFolderForSource(Path sourceFilePath, String packageName); static boolean isInSubDirectory(File dir, File file); static String pathToPackageName(String relativePath); static void createDirectory(Path dir, String dirDesc); static final String WINDUP_HOME; static final String WINDUP_RULESETS_DIR_SYSPROP; static final String WINDUP_LABELSETS_DIR_SYSPROP; static final String RULES_DIRECTORY_NAME; static final String LABELS_DIRECTORY_NAME; static final String IGNORE_DIRECTORY_NAME; static final String CACHE_DIRECTORY_NAME; static final String ADDONS_DIRECTORY_NAME; static String LIBRARY_DIRECTORY_NAME; static String BINARY_DIRECTORY_NAME; }### Answer:
@Test public void testWindupIgnoreDir() { Assert.assertEquals(Paths.get("ignore"), PathUtil.getUserIgnoreDir()); setUserHome("/foo"); Assert.assertEquals(Paths.get("/foo", ".mta", "ignore"), PathUtil.getUserIgnoreDir()); } |
### Question:
TickCounter { public TickCounter(TickHandler tickHandler, int maxTicks, int tickDuration) { this(tickHandler, maxTicks, tickDuration, 0); } TickCounter(TickHandler tickHandler, int maxTicks,
int tickDuration); TickCounter(TickHandler tickHandler, int maxTicks, int tickDuration,
int tickOffset); boolean update(); void reset(); int getTickCount(); boolean isRightTick(int tickInterval); }### Answer:
@Test public void testTickCounter() { int maxTicks = 75; int tickDuration = 30; int deltaMultiplier = 5; t = new TickCounter(new TickHandler() { @Override public void onTick() { tickCount++; } @Override public int getDeltaMultiplier() { return deltaMultiplier; } }, maxTicks, tickDuration); long startTime = System.currentTimeMillis(); while (!t.update()) { } long duration = System.currentTimeMillis() - startTime; assertEquals(tickCount, t.getTickCount()); assertEquals(maxTicks, t.getTickCount()); assertEquals(maxTicks * tickDuration / deltaMultiplier, duration); assertEquals(false, t.update()); assertEquals(tickCount, t.getTickCount()); assertEquals(maxTicks, t.getTickCount()); t.reset(); tickCount = 0; while (!t.update()) { } assertEquals(tickCount, t.getTickCount()); } |
### Question:
CollectionUtils { public static synchronized <T, E> T getKeyByValue(Map<T, E> map, E value) { Preconditions.checkNotNull(map, "The map cannot be null"); for (Entry<T, E> entry : map.entrySet()) { if (Objects.equals(value, entry.getValue())) { return entry.getKey(); } } return null; } private CollectionUtils(); static synchronized T getKeyByValue(Map<T, E> map, E value); static Map<K, V> sortByValue(
Map<K, V> map); static T findMostPopularElement(
List<T> list); }### Answer:
@Test public void testKeyByValue() { Map<Integer, Integer> map = new HashMap<>(); map.put(1, 1); map.put(2, 4); map.put(3, 9); map.put(4, 16); assertEquals((Integer) 1, CollectionUtils.getKeyByValue(map, 1)); assertEquals((Integer) 2, CollectionUtils.getKeyByValue(map, 4)); assertEquals((Integer) 3, CollectionUtils.getKeyByValue(map, 9)); assertEquals((Integer) 4, CollectionUtils.getKeyByValue(map, 16)); assertEquals(null, CollectionUtils.getKeyByValue(map, 5)); } |
### Question:
CollectionUtils { public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue( Map<K, V> map) { Preconditions.checkNotNull(map, "The map cannot be null"); List<Entry<K, V>> list = new ArrayList<>(map.entrySet()); list.sort(Entry.comparingByValue()); Map<K, V> result = new LinkedHashMap<>(); for (Entry<K, V> entry : list) { result.put(entry.getKey(), entry.getValue()); } return result; } private CollectionUtils(); static synchronized T getKeyByValue(Map<T, E> map, E value); static Map<K, V> sortByValue(
Map<K, V> map); static T findMostPopularElement(
List<T> list); }### Answer:
@Test public void testSortByValue() { Map<Integer, Integer> map = new HashMap<>(); map.put(1, 16); map.put(2, 8); map.put(3, 9); map.put(4, 5); map.put(5, 15); map = CollectionUtils.sortByValue(map); Integer[] tmp = map.keySet().toArray(new Integer[5]); assertEquals((Integer) 1, tmp[4]); assertEquals((Integer) 5, tmp[3]); assertEquals((Integer) 3, tmp[2]); assertEquals((Integer) 2, tmp[1]); assertEquals((Integer) 4, tmp[0]); } |
### Question:
CollectionUtils { public static <T extends Comparable<T>> T findMostPopularElement( List<T> list) { Preconditions.checkNotNull(list, "The list cannot be null"); Collections.sort(list); T previous = list.get(0); T popular = list.get(0); int count = 1; int maxCount = 1; for (int i = 1; i < list.size(); i++) { if (list.get(i) == previous) count++; else { if (count > maxCount) { popular = list.get(i - 1); maxCount = count; } previous = list.get(i); count = 1; } } return count > maxCount ? list.get(list.size() - 1) : popular; } private CollectionUtils(); static synchronized T getKeyByValue(Map<T, E> map, E value); static Map<K, V> sortByValue(
Map<K, V> map); static T findMostPopularElement(
List<T> list); }### Answer:
@Test public void testFindMostPopular() { Integer[] array = {1, 2, 2, 3, 4, 5, 5, 5, 6, 7, 7, 8}; List<Integer> list = new ArrayList<>(Arrays.asList(array)); assertEquals((Integer) 5, CollectionUtils.findMostPopularElement(list)); } |
### Question:
JwtUserFactory { public static JwtUser create(User user) { return new JwtUser( user.getId(), user.getUsername(), user.getFirstname(), user.getLastname(), user.getPassword(), user.getEmail(), user.getEnabled(), user.getLastPasswordResetDate().getTime(), mapUserRolesToGrantedAuthorities(user.getRoles()), user.getRoles() ); } private JwtUserFactory(); static JwtUser create(User user); }### Answer:
@Test public void whenCreateCalledWithUserModelThenExpectJwtUserDetailsToBeReturned() throws Exception { final User user = new User(); user.setId(USER_ID); user.setUsername(USERNAME); user.setPassword(PASSWORD); user.setFirstname(FIRSTNAME); user.setLastname(LASTNAME); user.setEmail(EMAIL); user.setEnabled(USER_ENABLED); user.setLastPasswordResetDate(LAST_PASSWORD_RESET_DATE); user.setRoles(createRoles(user)); final JwtUser userDetails = JwtUserFactory.create(user); assertEquals(userDetails.getId(), USER_ID); assertEquals(userDetails.getUsername(), USERNAME); assertEquals(userDetails.getPassword(), PASSWORD); assertEquals(userDetails.getFirstname(), FIRSTNAME); assertEquals(userDetails.getLastname(), LASTNAME); assertEquals(userDetails.getEmail(), EMAIL); assertEquals(userDetails.isEnabled(), USER_ENABLED); assertEquals(userDetails.getLastPasswordResetDate(), LAST_PASSWORD_RESET_DATE.getTime()); assertTrue(userDetails.getRoles().contains(RoleName.ROLE_ADMIN.name())); assertTrue(userDetails.getRoles().contains(RoleName.ROLE_USER.name())); assertTrue(userDetails.getAuthorities().contains(new SimpleGrantedAuthority(RoleName.ROLE_ADMIN.name()))); assertTrue(userDetails.getAuthorities().contains(new SimpleGrantedAuthority(RoleName.ROLE_USER.name()))); } |
### Question:
JwtAuthenticationEntryPoint implements AuthenticationEntryPoint { @Override public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException { response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized"); } @Override void commence(HttpServletRequest request, HttpServletResponse response,
AuthenticationException authException); }### Answer:
@Test public void whenCommenceCalledThenExpectUnauthorizedResponse() throws Exception { final JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint = new JwtAuthenticationEntryPoint(); jwtAuthenticationEntryPoint.commence(request, response, authException); verify(response, times(1)).sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized"); } |
### Question:
JwtUserDetailsService implements UserDetailsService { @Override public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { final User user = userRepository.findByUsername(username); if (user == null) { throw new UsernameNotFoundException(String.format("No user found with username '%s'.", username)); } else { return JwtUserFactory.create(user); } } @Autowired JwtUserDetailsService(UserRepository userRepository); @Override UserDetails loadUserByUsername(String username); }### Answer:
@Test public void whenLoadByUsernameCalledWithKnownUsernameThenExpectUserDetailsToBeReturned() throws Exception { PowerMock.mockStatic(JwtUserFactory.class); final User user = PowerMock.createMock(User.class); final JwtUser jwtUser = EasyMock.createMock(JwtUser.class); expect(userRepository.findByUsername(KNOWN_USERNAME)).andStubReturn(user); expect(JwtUserFactory.create(eq(user))).andStubReturn(jwtUser); PowerMock.replayAll(); final JwtUserDetailsService jwtUserDetailsService = new JwtUserDetailsService(userRepository); final JwtUser userDetails = (JwtUser) jwtUserDetailsService.loadUserByUsername(KNOWN_USERNAME); assertEquals(jwtUser, userDetails); PowerMock.verifyAll(); }
@Test(expected = UsernameNotFoundException.class) public void whenLoadByUsernameCalledWithUnknownUsernameThenExpectUsernameNotFoundException() throws Exception { expect(userRepository.findByUsername(UNKNOWN_USERNAME)).andStubReturn(null); PowerMock.replayAll(); final JwtUserDetailsService jwtUserDetailsService = new JwtUserDetailsService(userRepository); jwtUserDetailsService.loadUserByUsername(UNKNOWN_USERNAME); PowerMock.verifyAll(); } |
### Question:
BotStatusController extends AbstractRuntimeController { @PreAuthorize("hasRole('USER')") @RequestMapping(value = "/{botId}" + STATUS_RESOURCE_PATH, method = RequestMethod.GET) public ResponseEntity<?> getBotStatus(@AuthenticationPrincipal User user, @PathVariable String botId) { LOG.info("GET " + RUNTIME_ENDPOINT_BASE_URI + botId + STATUS_RESOURCE_PATH + " - getBotStatus()"); final BotStatus botStatus = botProcessService.getBotStatus(botId); return botStatus == null ? new ResponseEntity<>(HttpStatus.NOT_FOUND) : buildResponseEntity(botStatus, HttpStatus.OK); } @Autowired BotStatusController(BotStatusService botProcessService); @PreAuthorize("hasRole('USER')") @RequestMapping(value = "/{botId}" + STATUS_RESOURCE_PATH, method = RequestMethod.GET) ResponseEntity<?> getBotStatus(@AuthenticationPrincipal User user, @PathVariable String botId); @PreAuthorize("hasRole('USER')") @RequestMapping(value = STATUS_RESOURCE_PATH, method = RequestMethod.GET) ResponseEntity<?> getAllBotStatus(@AuthenticationPrincipal User user); }### Answer:
@Test public void whenGetBotStatusCalledWhenUserIsAuthenticatedThenExpectSuccess() throws Exception { given(botProcessService.getBotStatus(BOT_1_ID)).willReturn(bot1Status); mockMvc.perform(get(RUNTIME_ENDPOINT_BASE_URI + BOT_1_ID + STATUS_RESOURCE_PATH) .header("Authorization", "Bearer " + getJwt(VALID_USER_NAME, VALID_USER_PASSWORD))) .andDo(print()) .andExpect(status().isOk()) .andExpect(jsonPath("$.data.id").value(BOT_1_ID)) .andExpect(jsonPath("$.data.name").value(BOT_1_NAME)) .andExpect(jsonPath("$.data.status").value(BOT_1_STATUS)); verify(botProcessService, times(1)).getBotStatus(BOT_1_ID); }
@Test public void whenGetBotStatusCalledWithUnknownBotIdThenExpectNotFoundResponse() throws Exception { given(botProcessService.getBotStatus(UNKNOWN_BOT_ID)).willReturn(null); mockMvc.perform(get(RUNTIME_ENDPOINT_BASE_URI + UNKNOWN_BOT_ID + STATUS_RESOURCE_PATH) .header("Authorization", "Bearer " + getJwt(VALID_USER_NAME, VALID_USER_PASSWORD))) .andDo(print()) .andExpect(status().isNotFound()); verify(botProcessService, times(1)).getBotStatus(UNKNOWN_BOT_ID); } |
### Question:
JwtUtils { public String getUsernameFromTokenClaims(Claims claims) { try { final String username = claims.getSubject(); if (username == null) { final String errorMsg = "Failed to extract username claim from token!"; LOG.error(errorMsg); throw new JwtAuthenticationException(errorMsg); } return username; } catch (Exception e) { final String errorMsg = "Failed to extract username claim from token!"; LOG.error(errorMsg); throw new JwtAuthenticationException(errorMsg, e); } } Claims validateTokenAndGetClaims(String token); String generateToken(JwtUser userDetails); boolean canTokenBeRefreshed(Claims claims, Date lastPasswordReset); String refreshToken(String token); String getUsernameFromTokenClaims(Claims claims); List<GrantedAuthority> getRolesFromTokenClaims(Claims claims); }### Answer:
@Test public void testUsernameCanBeExtractedFromTokenClaims() throws Exception { when(claims.getSubject()).thenReturn(USERNAME); assertThat(jwtUtils.getUsernameFromTokenClaims(claims)).isEqualTo(USERNAME); verify(claims, times(1)).getSubject(); }
@Test(expected = JwtAuthenticationException.class) public void testExceptionThrownIfUsernameCannotBeExtractedFromTokenClaims() throws Exception { when(claims.getSubject()).thenReturn(null); jwtUtils.getUsernameFromTokenClaims(claims); verify(claims, times(1)).getSubject(); } |
### Question:
BotStatusController extends AbstractRuntimeController { @PreAuthorize("hasRole('USER')") @RequestMapping(value = STATUS_RESOURCE_PATH, method = RequestMethod.GET) public ResponseEntity<?> getAllBotStatus(@AuthenticationPrincipal User user) { LOG.info("GET " + RUNTIME_ENDPOINT_BASE_URI + STATUS_RESOURCE_PATH + " - getAllBotStatus()"); final List<BotStatus> allBotStatus = botProcessService.getAllBotStatus(); return allBotStatus.isEmpty() ? new ResponseEntity<>(HttpStatus.NOT_FOUND) : buildResponseEntity(allBotStatus, HttpStatus.OK); } @Autowired BotStatusController(BotStatusService botProcessService); @PreAuthorize("hasRole('USER')") @RequestMapping(value = "/{botId}" + STATUS_RESOURCE_PATH, method = RequestMethod.GET) ResponseEntity<?> getBotStatus(@AuthenticationPrincipal User user, @PathVariable String botId); @PreAuthorize("hasRole('USER')") @RequestMapping(value = STATUS_RESOURCE_PATH, method = RequestMethod.GET) ResponseEntity<?> getAllBotStatus(@AuthenticationPrincipal User user); }### Answer:
@Test public void whenGetAllBotStatusCalledWhenUserIsAuthenticatedThenExpectSuccess() throws Exception { final List<BotStatus> allBotStatus = new ArrayList<>(); allBotStatus.add(bot1Status); allBotStatus.add(bot2Status); given(botProcessService.getAllBotStatus()).willReturn(allBotStatus); mockMvc.perform(get(RUNTIME_ENDPOINT_BASE_URI + STATUS_RESOURCE_PATH) .header("Authorization", "Bearer " + getJwt(VALID_USER_NAME, VALID_USER_PASSWORD))) .andDo(print()) .andExpect(status().isOk()) .andExpect(jsonPath("$.data.[0].id").value(BOT_1_ID)) .andExpect(jsonPath("$.data.[0].name").value(BOT_1_NAME)) .andExpect(jsonPath("$.data.[0].status").value(BOT_1_STATUS)) .andExpect(jsonPath("$.data.[1].id").value(BOT_2_ID)) .andExpect(jsonPath("$.data.[1].name").value(BOT_2_NAME)) .andExpect(jsonPath("$.data.[1].status").value(BOT_2_STATUS)); verify(botProcessService, times(1)).getAllBotStatus(); } |
### Question:
OptionalConfig { public Map<String, String> getItems() { return items; } OptionalConfig(); Map<String, String> getItems(); void setItems(Map<String, String> items); @Override String toString(); }### Answer:
@Test public void testAddingAndFetchingOptionalConfigItems() throws Exception { final OptionalConfig strategyConfig = new OptionalConfig(); strategyConfig.getItems().put(BUY_FEE_CONFIG_ITEM_KEY, BUY_FEE_CONFIG_ITEM_VALUE); strategyConfig.getItems().put(SELL_FEE_CONFIG_ITEM_KEY, SELL_FEE_CONFIG_ITEM_VALUE); assertEquals(2, strategyConfig.getItems().size()); assertEquals(BUY_FEE_CONFIG_ITEM_VALUE, strategyConfig.getItems().get(BUY_FEE_CONFIG_ITEM_KEY)); assertEquals(SELL_FEE_CONFIG_ITEM_VALUE, strategyConfig.getItems().get(SELL_FEE_CONFIG_ITEM_KEY)); } |
### Question:
JwtUtils { Date getIssuedAtDateFromTokenClaims(Claims claims) throws JwtAuthenticationException { try { return claims.getIssuedAt(); } catch (Exception e) { final String errorMsg = "Failed to extract iat claim from token!"; LOG.error(errorMsg, e); throw new JwtAuthenticationException(errorMsg, e); } } Claims validateTokenAndGetClaims(String token); String generateToken(JwtUser userDetails); boolean canTokenBeRefreshed(Claims claims, Date lastPasswordReset); String refreshToken(String token); String getUsernameFromTokenClaims(Claims claims); List<GrantedAuthority> getRolesFromTokenClaims(Claims claims); }### Answer:
@Test public void testIssuedAtDateCanBeExtractedFromTokenClaims() throws Exception { when(claims.getIssuedAt()).thenReturn(ISSUED_AT_DATE); assertThat(jwtUtils.getIssuedAtDateFromTokenClaims(claims)) .isCloseTo(ISSUED_AT_DATE, GRADLE_FRIENDLY_TIME_TOLERANCE_IN_MILLIS); verify(claims, times(1)).getIssuedAt(); } |
### Question:
JwtUtils { Date getExpirationDateFromTokenClaims(Claims claims) throws JwtAuthenticationException { try { return claims.getExpiration(); } catch (Exception e) { final String errorMsg = "Failed to extract expiration claim from token!"; LOG.error(errorMsg, e); throw new JwtAuthenticationException(errorMsg, e); } } Claims validateTokenAndGetClaims(String token); String generateToken(JwtUser userDetails); boolean canTokenBeRefreshed(Claims claims, Date lastPasswordReset); String refreshToken(String token); String getUsernameFromTokenClaims(Claims claims); List<GrantedAuthority> getRolesFromTokenClaims(Claims claims); }### Answer:
@Test public void testExpirationDateCanBeExtractedFromTokenClaims() throws Exception { when(claims.getExpiration()).thenReturn(EXPIRATION_DATE); assertThat(jwtUtils.getExpirationDateFromTokenClaims(claims)) .isCloseTo(EXPIRATION_DATE, GRADLE_FRIENDLY_TIME_TOLERANCE_IN_MILLIS); verify(claims, times(1)).getExpiration(); } |
### Question:
JwtUtils { public List<GrantedAuthority> getRolesFromTokenClaims(Claims claims) throws JwtAuthenticationException { final List<GrantedAuthority> roles = new ArrayList<>(); try { @SuppressWarnings("unchecked") final List<String> rolesFromClaim = (List<String>) claims.get(CLAIM_KEY_ROLES); for (final String roleFromClaim : rolesFromClaim) { roles.add(new SimpleGrantedAuthority(roleFromClaim)); } return roles; } catch (Exception e) { final String errorMsg = "Failed to extract roles claim from token!"; LOG.error(errorMsg, e); throw new JwtAuthenticationException(errorMsg, e); } } Claims validateTokenAndGetClaims(String token); String generateToken(JwtUser userDetails); boolean canTokenBeRefreshed(Claims claims, Date lastPasswordReset); String refreshToken(String token); String getUsernameFromTokenClaims(Claims claims); List<GrantedAuthority> getRolesFromTokenClaims(Claims claims); }### Answer:
@Test public void testRolesCanBeExtractedFromTokenClaims() throws Exception { when(claims.get(JwtUtils.CLAIM_KEY_ROLES)).thenReturn(ROLES); final List<GrantedAuthority> roles = jwtUtils.getRolesFromTokenClaims(claims); assertThat(roles.size()).isEqualTo(2); assertThat(roles.get(0).getAuthority()).isEqualTo(RoleName.ROLE_ADMIN.name()); assertThat(roles.get(1).getAuthority()).isEqualTo(RoleName.ROLE_USER.name()); verify(claims, times(1)).get(JwtUtils.CLAIM_KEY_ROLES); } |
### Question:
JwtUtils { Date getLastPasswordResetDateFromTokenClaims(Claims claims) { Date lastPasswordResetDate; try { lastPasswordResetDate = new Date((Long) claims.get(CLAIM_KEY_LAST_PASSWORD_CHANGE_DATE)); } catch (Exception e) { LOG.error("Failed to extract lastPasswordResetDate claim from token!", e); lastPasswordResetDate = null; } return lastPasswordResetDate; } Claims validateTokenAndGetClaims(String token); String generateToken(JwtUser userDetails); boolean canTokenBeRefreshed(Claims claims, Date lastPasswordReset); String refreshToken(String token); String getUsernameFromTokenClaims(Claims claims); List<GrantedAuthority> getRolesFromTokenClaims(Claims claims); }### Answer:
@Test public void testLastPasswordResetDateCanBeExtractedFromTokenClaims() throws Exception { when(claims.get(JwtUtils.CLAIM_KEY_LAST_PASSWORD_CHANGE_DATE)) .thenReturn(LAST_PASSWORD_RESET_DATE.getTime()); assertThat(jwtUtils.getLastPasswordResetDateFromTokenClaims(claims)) .isCloseTo(LAST_PASSWORD_RESET_DATE, GRADLE_FRIENDLY_TIME_TOLERANCE_IN_MILLIS); } |
### Question:
JwtUtils { public Claims validateTokenAndGetClaims(String token) { try { final Claims claims = getClaimsFromToken(token); final Date created = getIssuedAtDateFromTokenClaims(claims); final Date lastPasswordResetDate = getLastPasswordResetDateFromTokenClaims(claims); if (isCreatedBeforeLastPasswordReset(created, lastPasswordResetDate)) { final String errorMsg = "Invalid token! Created date claim is before last password reset date." + " Created date: " + created + " Password reset date: " + lastPasswordResetDate; LOG.error(errorMsg); throw new JwtAuthenticationException(errorMsg); } return claims; } catch (Exception e) { final String errorMsg = "Invalid token! Details: " + e.getMessage(); LOG.error(errorMsg, e); throw new JwtAuthenticationException(errorMsg, e); } } Claims validateTokenAndGetClaims(String token); String generateToken(JwtUser userDetails); boolean canTokenBeRefreshed(Claims claims, Date lastPasswordReset); String refreshToken(String token); String getUsernameFromTokenClaims(Claims claims); List<GrantedAuthority> getRolesFromTokenClaims(Claims claims); }### Answer:
@Test public void whenValidateTokenCalledWithNonExpiredTokenThenExpectSuccess() throws Exception { final String token = createToken(); assertThat(jwtUtils.validateTokenAndGetClaims(token)).isNotNull(); }
@Test(expected = JwtAuthenticationException.class) public void whenValidateTokenCalledWithExpiredTokenThenExpectFailure() throws Exception { ReflectionTestUtils.setField(jwtUtils, "allowedClockSkewInSecs", 0L); ReflectionTestUtils.setField(jwtUtils, "expirationInSecs", 0L); final String token = createToken(); jwtUtils.validateTokenAndGetClaims(token); }
@Test(expected = JwtAuthenticationException.class) public void whenValidateTokenCalledWithCreatedDateEarlierThanLastPasswordResetDateThenExpectFailure() throws Exception { final String token = createTokenWithInvalidCreationDate(); jwtUtils.validateTokenAndGetClaims(token); } |
### Question:
Properlty { public Optional<Double> getDouble(String key) { return get(key).map(Double::parseDouble); } Properlty(boolean caseSensitive, Map<String, PropertyValue> properties); static ProperltyBuilder builder(); Optional<String> get(String key); String get(String key, String defaultValue); Optional<T> get(String key, Function<String, T> map); T get(String key, T defaultValue, Function<String, T> map); Optional<Integer> getInt(String key); int getInt(String key, int defaultValue); Optional<Boolean> getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); Optional<Double> getDouble(String key); double getDouble(String key, double defaultValue); Optional<Float> getFloat(String key); float getFloat(String key, float defaultValue); Optional<Long> getLong(String key); long getLong(String key, long defaultValue); Optional<BigDecimal> getBigDecimal(String key); BigDecimal getBigDecimal(String key, BigDecimal defaultValue); Optional<BigInteger> getBigInteger(String key); BigInteger getBigInteger(String key, BigInteger defaultValue); Optional<T> getEnum(String key, Class<T> type); T getEnum(String key, T defaultValue); String[] getArray(String key); String[] getArray(String key, String separator); List<String> getList(String key); List<String> getList(String key, String separator); List<T> getList(String key, Function<String, T> map); List<T> getList(String key, String separator, Function<String, T> map); }### Answer:
@Test public void shouldReturnEmptyOptionalDouble() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "value.one"); properties.put("key.two", "value.two"); final Properlty prop = buildProperlty(properties); assertFalse(prop.getDouble("key.three").isPresent()); }
@Test public void shouldReturnDefaultDouble() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "1"); final Properlty prop = buildProperlty(properties); assertEquals(1d, prop.getDouble("key.one", 1.1111d), 0.1d); assertEquals(10d, prop.getDouble("key.two", 10d), 0.1d); }
@Test(expected=NumberFormatException.class) public void shouldThrowExceptionParsingWrongDouble() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "not a number"); final Properlty prop = buildProperlty(properties); prop.getDouble("key.one"); } |
### Question:
Properlty { public Optional<Float> getFloat(String key) { return get(key).map(Float::parseFloat); } Properlty(boolean caseSensitive, Map<String, PropertyValue> properties); static ProperltyBuilder builder(); Optional<String> get(String key); String get(String key, String defaultValue); Optional<T> get(String key, Function<String, T> map); T get(String key, T defaultValue, Function<String, T> map); Optional<Integer> getInt(String key); int getInt(String key, int defaultValue); Optional<Boolean> getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); Optional<Double> getDouble(String key); double getDouble(String key, double defaultValue); Optional<Float> getFloat(String key); float getFloat(String key, float defaultValue); Optional<Long> getLong(String key); long getLong(String key, long defaultValue); Optional<BigDecimal> getBigDecimal(String key); BigDecimal getBigDecimal(String key, BigDecimal defaultValue); Optional<BigInteger> getBigInteger(String key); BigInteger getBigInteger(String key, BigInteger defaultValue); Optional<T> getEnum(String key, Class<T> type); T getEnum(String key, T defaultValue); String[] getArray(String key); String[] getArray(String key, String separator); List<String> getList(String key); List<String> getList(String key, String separator); List<T> getList(String key, Function<String, T> map); List<T> getList(String key, String separator, Function<String, T> map); }### Answer:
@Test public void shouldReturnEmptyOptionalFloat() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "value.one"); properties.put("key.two", "value.two"); final Properlty prop = buildProperlty(properties); assertFalse(prop.getFloat("key.three").isPresent()); }
@Test public void shouldReturnDefaultFloat() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "1"); final Properlty prop = buildProperlty(properties); assertEquals(1f, prop.getFloat("key.one", 10), 0.1f); assertEquals(10f, prop.getFloat("key.two", 10), 0.1f); }
@Test(expected=NumberFormatException.class) public void shouldThrowExceptionParsingWrongFloat() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "not a number"); final Properlty prop = buildProperlty(properties); prop.getFloat("key.one"); } |
### Question:
Properlty { public Optional<Long> getLong(String key) { return get(key).map(Long::parseLong); } Properlty(boolean caseSensitive, Map<String, PropertyValue> properties); static ProperltyBuilder builder(); Optional<String> get(String key); String get(String key, String defaultValue); Optional<T> get(String key, Function<String, T> map); T get(String key, T defaultValue, Function<String, T> map); Optional<Integer> getInt(String key); int getInt(String key, int defaultValue); Optional<Boolean> getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); Optional<Double> getDouble(String key); double getDouble(String key, double defaultValue); Optional<Float> getFloat(String key); float getFloat(String key, float defaultValue); Optional<Long> getLong(String key); long getLong(String key, long defaultValue); Optional<BigDecimal> getBigDecimal(String key); BigDecimal getBigDecimal(String key, BigDecimal defaultValue); Optional<BigInteger> getBigInteger(String key); BigInteger getBigInteger(String key, BigInteger defaultValue); Optional<T> getEnum(String key, Class<T> type); T getEnum(String key, T defaultValue); String[] getArray(String key); String[] getArray(String key, String separator); List<String> getList(String key); List<String> getList(String key, String separator); List<T> getList(String key, Function<String, T> map); List<T> getList(String key, String separator, Function<String, T> map); }### Answer:
@Test public void shouldReturnEmptyOptionalLong() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "value.one"); properties.put("key.two", "value.two"); final Properlty prop = buildProperlty(properties); assertFalse(prop.getLong("key.three").isPresent()); }
@Test public void shouldReturnDefaultLong() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "1"); final Properlty prop = buildProperlty(properties); assertEquals(1l, prop.getLong("key.one", 10l)); assertEquals(10l, prop.getLong("key.two", 10l)); }
@Test(expected=NumberFormatException.class) public void shouldThrowExceptionParsingWrongLong() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "not a number"); final Properlty prop = buildProperlty(properties); prop.getLong("key.one"); } |
### Question:
Properlty { public Optional<BigDecimal> getBigDecimal(String key) { return get(key).map((val) -> new BigDecimal(val)); } Properlty(boolean caseSensitive, Map<String, PropertyValue> properties); static ProperltyBuilder builder(); Optional<String> get(String key); String get(String key, String defaultValue); Optional<T> get(String key, Function<String, T> map); T get(String key, T defaultValue, Function<String, T> map); Optional<Integer> getInt(String key); int getInt(String key, int defaultValue); Optional<Boolean> getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); Optional<Double> getDouble(String key); double getDouble(String key, double defaultValue); Optional<Float> getFloat(String key); float getFloat(String key, float defaultValue); Optional<Long> getLong(String key); long getLong(String key, long defaultValue); Optional<BigDecimal> getBigDecimal(String key); BigDecimal getBigDecimal(String key, BigDecimal defaultValue); Optional<BigInteger> getBigInteger(String key); BigInteger getBigInteger(String key, BigInteger defaultValue); Optional<T> getEnum(String key, Class<T> type); T getEnum(String key, T defaultValue); String[] getArray(String key); String[] getArray(String key, String separator); List<String> getList(String key); List<String> getList(String key, String separator); List<T> getList(String key, Function<String, T> map); List<T> getList(String key, String separator, Function<String, T> map); }### Answer:
@Test public void shouldReturnDefaultBigDecimal() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "1"); final Properlty prop = buildProperlty(properties); assertEquals(1, prop.getBigDecimal("key.one", new BigDecimal(10)).intValue()); assertEquals(10, prop.getBigDecimal("key.two", new BigDecimal(10)).intValue()); } |
### Question:
Properlty { public Optional<BigInteger> getBigInteger(String key) { return get(key).map((val) -> new BigInteger(val)); } Properlty(boolean caseSensitive, Map<String, PropertyValue> properties); static ProperltyBuilder builder(); Optional<String> get(String key); String get(String key, String defaultValue); Optional<T> get(String key, Function<String, T> map); T get(String key, T defaultValue, Function<String, T> map); Optional<Integer> getInt(String key); int getInt(String key, int defaultValue); Optional<Boolean> getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); Optional<Double> getDouble(String key); double getDouble(String key, double defaultValue); Optional<Float> getFloat(String key); float getFloat(String key, float defaultValue); Optional<Long> getLong(String key); long getLong(String key, long defaultValue); Optional<BigDecimal> getBigDecimal(String key); BigDecimal getBigDecimal(String key, BigDecimal defaultValue); Optional<BigInteger> getBigInteger(String key); BigInteger getBigInteger(String key, BigInteger defaultValue); Optional<T> getEnum(String key, Class<T> type); T getEnum(String key, T defaultValue); String[] getArray(String key); String[] getArray(String key, String separator); List<String> getList(String key); List<String> getList(String key, String separator); List<T> getList(String key, Function<String, T> map); List<T> getList(String key, String separator, Function<String, T> map); }### Answer:
@Test public void shouldReturnDefaultBigInteger() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "1"); final Properlty prop = buildProperlty(properties); assertEquals(1, prop.getBigInteger("key.one", new BigInteger("10")).intValue()); assertEquals(10, prop.getBigInteger("key.two", new BigInteger("10")).intValue()); } |
### Question:
Properlty { public <T extends Enum<T>> Optional<T> getEnum(String key, Class<T> type) { return get(key).map(value -> Enum.valueOf(type, value)); } Properlty(boolean caseSensitive, Map<String, PropertyValue> properties); static ProperltyBuilder builder(); Optional<String> get(String key); String get(String key, String defaultValue); Optional<T> get(String key, Function<String, T> map); T get(String key, T defaultValue, Function<String, T> map); Optional<Integer> getInt(String key); int getInt(String key, int defaultValue); Optional<Boolean> getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); Optional<Double> getDouble(String key); double getDouble(String key, double defaultValue); Optional<Float> getFloat(String key); float getFloat(String key, float defaultValue); Optional<Long> getLong(String key); long getLong(String key, long defaultValue); Optional<BigDecimal> getBigDecimal(String key); BigDecimal getBigDecimal(String key, BigDecimal defaultValue); Optional<BigInteger> getBigInteger(String key); BigInteger getBigInteger(String key, BigInteger defaultValue); Optional<T> getEnum(String key, Class<T> type); T getEnum(String key, T defaultValue); String[] getArray(String key); String[] getArray(String key, String separator); List<String> getList(String key); List<String> getList(String key, String separator); List<T> getList(String key, Function<String, T> map); List<T> getList(String key, String separator, Function<String, T> map); }### Answer:
@Test public void shouldReturnEmptyOptionalEnum() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "value.one"); properties.put("key.two", "value.two"); final Properlty prop = buildProperlty(properties); assertFalse(prop.getEnum("key.three", NeedSomebodyToLove.class).isPresent()); }
@Test public void shouldReturnDefaultEnum() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "ME"); final Properlty prop = buildProperlty(properties); assertEquals(NeedSomebodyToLove.ME, prop.getEnum("key.one", NeedSomebodyToLove.THEM)); assertEquals(NeedSomebodyToLove.THEM, prop.getEnum("key.two", NeedSomebodyToLove.THEM)); }
@Test(expected=IllegalArgumentException.class) public void shouldThrowExceptionParsingWrongEnumLong() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "not an enum"); final Properlty prop = buildProperlty(properties); prop.getEnum("key.one", NeedSomebodyToLove.class); } |
### Question:
Properlty { public String[] getArray(String key) { return getArray(key, Default.LIST_SEPARATOR); } Properlty(boolean caseSensitive, Map<String, PropertyValue> properties); static ProperltyBuilder builder(); Optional<String> get(String key); String get(String key, String defaultValue); Optional<T> get(String key, Function<String, T> map); T get(String key, T defaultValue, Function<String, T> map); Optional<Integer> getInt(String key); int getInt(String key, int defaultValue); Optional<Boolean> getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); Optional<Double> getDouble(String key); double getDouble(String key, double defaultValue); Optional<Float> getFloat(String key); float getFloat(String key, float defaultValue); Optional<Long> getLong(String key); long getLong(String key, long defaultValue); Optional<BigDecimal> getBigDecimal(String key); BigDecimal getBigDecimal(String key, BigDecimal defaultValue); Optional<BigInteger> getBigInteger(String key); BigInteger getBigInteger(String key, BigInteger defaultValue); Optional<T> getEnum(String key, Class<T> type); T getEnum(String key, T defaultValue); String[] getArray(String key); String[] getArray(String key, String separator); List<String> getList(String key); List<String> getList(String key, String separator); List<T> getList(String key, Function<String, T> map); List<T> getList(String key, String separator, Function<String, T> map); }### Answer:
@Test public void shouldReturnValueToArray() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "111,AAAAA,BBB"); final Properlty prop = buildProperlty(properties); final String[] values = prop.getArray("key.one"); assertEquals(3, values.length); assertEquals("111", values[0]); assertEquals("AAAAA", values[1]); assertEquals("BBB", values[2]); assertEquals(0, prop.getArray("key.three").length); } |
### Question:
FileUtils { public static InputStream getStream(String resourcePath) throws FileNotFoundException { if (resourcePath.startsWith(CLASSPATH_PREFIX)) { final String resourceName = resourcePath.substring(CLASSPATH_PREFIX.length()); final InputStream is = FileUtils.class.getClassLoader().getResourceAsStream(resourceName); if (is == null) { throw new FileNotFoundException("Cannot retrieve classpath resource [" + resourceName + "]"); } return is; } if (resourcePath.startsWith(FILE_PATH_PREFIX)) { return new FileInputStream(resourcePath.substring(FILE_PATH_PREFIX.length())); } return new FileInputStream(resourcePath); } private FileUtils(); static InputStream getStream(String resourcePath); static final String FILE_PATH_PREFIX; static final String CLASSPATH_PREFIX; }### Answer:
@Test public void shouldReadFileFromRelativePath() throws IOException { try (InputStream is = FileUtils.getStream("./src/test/files/test1.properties")) { final String content = toString(is); assertNotNull(content); assertTrue(content.contains("keyOne")); } }
@Test public void shouldReadFileFromRelativePathWithPrefix() throws IOException { try (InputStream is = FileUtils.getStream("file:src/test/files/test1.properties")) { final String content = toString(is); assertNotNull(content); assertTrue(content.contains("keyOne")); } }
@Test public void shouldReadFileFromAbsolutePath() throws IOException { final String absolutePath = new File("src/test/files/test1.properties").getAbsolutePath(); try (InputStream is = FileUtils.getStream(absolutePath)) { final String content = toString(is); assertNotNull(content); assertTrue(content.contains("keyOne")); } }
@Test public void shouldReadFileFromAbsolutePathWithPrefix() throws IOException { final String absolutePath = new File("src/test/files/test1.properties").getAbsolutePath(); try (InputStream is = FileUtils.getStream("file:" + absolutePath)) { final String content = toString(is); assertNotNull(content); assertTrue(content.contains("keyOne")); } }
@Test public void shouldReadFileFromClasspath() throws IOException { try (InputStream is = FileUtils.getStream("classpath:resource1.properties")) { final String content = toString(is); assertNotNull(content); assertTrue(content.contains("name=resource1")); } }
@Test public void shouldReadFileFromClasspathFolder() throws IOException { try (InputStream is = FileUtils.getStream("classpath:./inner/resource2.properties")) { final String content = toString(is); assertNotNull(content); assertTrue(content.contains("name=resource2")); } }
@Test public void shouldThrowFileNotFoundExceptionForMissingFileFromClasspath() throws IOException { try { FileUtils.getStream("classpath:NOT_EXISTING_FILE"); fail("Should have thrown a FileNotFoundException"); } catch (final FileNotFoundException e) { assertTrue(e.getMessage().contains("NOT_EXISTING_FILE")); } }
@Test public void shouldThrowFileNotFoundExceptionForMissingFile() throws IOException { try { FileUtils.getStream("file:NOT_EXISTING_FILE"); fail("Should have thrown a FileNotFoundException"); } catch (final FileNotFoundException e) { assertTrue(e.getMessage().contains("NOT_EXISTING_FILE")); } } |
### Question:
Properlty { public Optional<Integer> getInt(String key) { return get(key).map(Integer::parseInt); } Properlty(boolean caseSensitive, Map<String, PropertyValue> properties); static ProperltyBuilder builder(); Optional<String> get(String key); String get(String key, String defaultValue); Optional<T> get(String key, Function<String, T> map); T get(String key, T defaultValue, Function<String, T> map); Optional<Integer> getInt(String key); int getInt(String key, int defaultValue); Optional<Boolean> getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); Optional<Double> getDouble(String key); double getDouble(String key, double defaultValue); Optional<Float> getFloat(String key); float getFloat(String key, float defaultValue); Optional<Long> getLong(String key); long getLong(String key, long defaultValue); Optional<BigDecimal> getBigDecimal(String key); BigDecimal getBigDecimal(String key, BigDecimal defaultValue); Optional<BigInteger> getBigInteger(String key); BigInteger getBigInteger(String key, BigInteger defaultValue); Optional<T> getEnum(String key, Class<T> type); T getEnum(String key, T defaultValue); String[] getArray(String key); String[] getArray(String key, String separator); List<String> getList(String key); List<String> getList(String key, String separator); List<T> getList(String key, Function<String, T> map); List<T> getList(String key, String separator, Function<String, T> map); }### Answer:
@Test public void shouldReturnEmptyOptionalInteger() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "value.one"); properties.put("key.two", "value.two"); final Properlty prop = buildProperlty(properties); assertFalse(prop.getInt("key.three").isPresent()); }
@Test public void shouldReturnDefaultInteger() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "1"); final Properlty prop = buildProperlty(properties); assertEquals(1, prop.getInt("key.one", 10)); assertEquals(10, prop.getInt("key.two", 10)); }
@Test(expected=NumberFormatException.class) public void shouldThrowExceptionParsingWrongInteger() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "not a number"); final Properlty prop = buildProperlty(properties); prop.getInt("key.one"); } |
### Question:
SystemPropertiesReader implements Reader { @Override public Map<String, PropertyValue> read() { final Map<String, PropertyValue> properties = new HashMap<>(); final Properties systemProperties = System.getProperties(); for(final Entry<Object, Object> x : systemProperties.entrySet()) { properties.put((String)x.getKey(), PropertyValue.of((String)x.getValue())); } return properties; } @Override Map<String, PropertyValue> read(); }### Answer:
@Test public void shouldReadSystemProperties() { final String key = UUID.randomUUID().toString(); final String value = UUID.randomUUID().toString(); System.setProperty(key, value); final Map<String, PropertyValue> systemProperties = new SystemPropertiesReader().read(); assertNotNull(systemProperties); assertTrue(systemProperties.containsKey(key)); assertEquals(value, systemProperties.get(key).getValue()); } |
### Question:
EnvironmentVariablesReader implements Reader { @Override public Map<String, PropertyValue> read() { return envSupplier.get().entrySet().stream() .collect(Collectors.toMap( e -> getKey(e.getKey()), e -> PropertyValue.of(e.getValue()).resolvable(false) )); } EnvironmentVariablesReader(); EnvironmentVariablesReader(Supplier<Map<String, String>> envSupplier); @Override Map<String, PropertyValue> read(); EnvironmentVariablesReader replace(String from, String to); }### Answer:
@Test public void shouldReturnUnresolvableEnvironmentVariables() { final Map<String, PropertyValue> var = new EnvironmentVariablesReader().read(); assertNotNull(var); assertFalse(var.isEmpty()); var.forEach((key, value) -> { assertFalse(value.isResolvable()); }); } |
### Question:
PriorityQueueDecoratorReader implements Reader { @Override public Map<String, PropertyValue> read() { final Map<String, PropertyValue> result = new LinkedHashMap<>(); readersMap.forEach((priority, readers) -> { readers.forEach(reader -> { final Map<String, PropertyValue> entries = reader.read(); result.putAll(entries); }); }) ; return result; } @Override Map<String, PropertyValue> read(); void add(Reader reader, int priority); }### Answer:
@Test public void shouldReturnEmptyMapIfEmpty() { final PriorityQueueDecoratorReader queue = new PriorityQueueDecoratorReader(); final Map<String, PropertyValue> prop = queue.read(); assertNotNull(prop); assertTrue(prop.isEmpty()); } |
### Question:
Properlty { public Optional<Boolean> getBoolean(String key) { return get(key).map(value -> { if ( "true".equalsIgnoreCase(value) ) return true; else if ( "false".equalsIgnoreCase(value) ) return false; else throw new RuntimeException("Cannot parse boolean value: [" + value+ "]"); }); } Properlty(boolean caseSensitive, Map<String, PropertyValue> properties); static ProperltyBuilder builder(); Optional<String> get(String key); String get(String key, String defaultValue); Optional<T> get(String key, Function<String, T> map); T get(String key, T defaultValue, Function<String, T> map); Optional<Integer> getInt(String key); int getInt(String key, int defaultValue); Optional<Boolean> getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); Optional<Double> getDouble(String key); double getDouble(String key, double defaultValue); Optional<Float> getFloat(String key); float getFloat(String key, float defaultValue); Optional<Long> getLong(String key); long getLong(String key, long defaultValue); Optional<BigDecimal> getBigDecimal(String key); BigDecimal getBigDecimal(String key, BigDecimal defaultValue); Optional<BigInteger> getBigInteger(String key); BigInteger getBigInteger(String key, BigInteger defaultValue); Optional<T> getEnum(String key, Class<T> type); T getEnum(String key, T defaultValue); String[] getArray(String key); String[] getArray(String key, String separator); List<String> getList(String key); List<String> getList(String key, String separator); List<T> getList(String key, Function<String, T> map); List<T> getList(String key, String separator, Function<String, T> map); }### Answer:
@Test public void shouldReturnEmptyOptionalBoolean() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "value.one"); properties.put("key.two", "value.two"); final Properlty prop = buildProperlty(properties); assertFalse(prop.getBoolean("key.three").isPresent()); }
@Test public void shouldReturnDefaultBoolean() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "true"); final Properlty prop = buildProperlty(properties); assertTrue(prop.getBoolean("key.one", false)); assertFalse(prop.getBoolean("key.two", false)); assertTrue(prop.getBoolean("key.two", true)); }
@Test(expected=RuntimeException.class) public void shouldThrowExceptionParsingWrongBoolean() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "not a bool"); final Properlty prop = buildProperlty(properties); prop.getBoolean("key.one"); } |
### Question:
MinikubeDockerEnvParser { public static Map<String, String> parse(List<String> keyValueStrings) { Map<String, String> environmentMap = new HashMap<>(); for (String keyValueString : keyValueStrings) { String[] keyValuePair = keyValueString.split("=", 2); if (keyValuePair.length < 2) { throw new IllegalArgumentException( "Error while parsing minikube's Docker environment: environment variable string not in KEY=VALUE format"); } if (keyValuePair[0].length() == 0) { throw new IllegalArgumentException( "Error while parsing minikube's Docker environment: encountered empty environment variable name"); } environmentMap.put(keyValuePair[0], keyValuePair[1]); } return environmentMap; } private MinikubeDockerEnvParser(); static Map<String, String> parse(List<String> keyValueStrings); }### Answer:
@Test public void testParse_success() { List<String> keyValueStrings = Arrays.asList( "SOME_VARIABLE_1=SOME_VALUE_1", "SOME_VARIABLE_2=SOME_VALUE_2", "SOME_VARIABLE_3="); Map<String, String> expectedEnvironment = new HashMap<>(); expectedEnvironment.put("SOME_VARIABLE_1", "SOME_VALUE_1"); expectedEnvironment.put("SOME_VARIABLE_2", "SOME_VALUE_2"); expectedEnvironment.put("SOME_VARIABLE_3", ""); Map<String, String> environment = MinikubeDockerEnvParser.parse(keyValueStrings); Assert.assertEquals(expectedEnvironment, environment); }
@Test public void testParse_variableNameEmpty() { List<String> keyValueStrings = Arrays.asList("SOME_VARIABLE_1=SOME_VALUE_1", "=SOME_VALUE_2", "SOME_VARIABLE_3="); try { MinikubeDockerEnvParser.parse(keyValueStrings); Assert.fail("Expected an IllegalArgumentException to be thrown"); } catch (IllegalArgumentException ex) { Assert.assertEquals( "Error while parsing minikube's Docker environment: encountered empty environment variable name", ex.getMessage()); } }
@Test public void testParse_invalidFormat() { List<String> keyValueStrings = Arrays.asList("SOME_VARIABLE_1=SOME_VALUE_1", "SOME_VARIABLE_2", "SOME_VARIABLE_3="); try { MinikubeDockerEnvParser.parse(keyValueStrings); Assert.fail("Expected an IllegalArgumentException to be thrown"); } catch (IllegalArgumentException ex) { Assert.assertEquals( "Error while parsing minikube's Docker environment: environment variable string not in KEY=VALUE format", ex.getMessage()); } } |
### Question:
AbstractMinikubeMojo extends AbstractMojo { @VisibleForTesting List<String> buildMinikubeCommand() { List<String> execString = new ArrayList<>(); execString.add(minikube); execString.add(getCommand()); if (flags != null) { execString.addAll(flags); } execString.addAll(getMoreFlags()); return execString; } @Override void execute(); }### Answer:
@Test public void testBuildMinikubeCommand() { spyAbstractMinikubeMojo.setMinikube("path/to/minikube"); spyAbstractMinikubeMojo.setFlags(ImmutableList.of("someFlag1", "someFlag2")); Mockito.when(spyAbstractMinikubeMojo.getCommand()).thenReturn("somecommand"); Mockito.when(spyAbstractMinikubeMojo.getMoreFlags()) .thenReturn(ImmutableList.of("moreFlag1", "moreFlag2")); Assert.assertEquals( Arrays.asList( "path/to/minikube", "somecommand", "someFlag1", "someFlag2", "moreFlag1", "moreFlag2"), spyAbstractMinikubeMojo.buildMinikubeCommand()); } |
### Question:
AbstractMinikubeMojo extends AbstractMojo { @Override public void execute() throws MojoExecutionException { List<String> minikubeCommand = buildMinikubeCommand(); try { commandExecutorSupplier.get().setLogger(mavenBuildLogger).run(minikubeCommand); } catch (InterruptedException | IOException ex) { throw new MojoExecutionException(getDescription() + " failed", ex); } } @Override void execute(); }### Answer:
@Test public void testExecute() throws IOException, MojoExecutionException, InterruptedException { List<String> minikubeCommand = Arrays.asList("some", "command"); Mockito.doReturn(minikubeCommand).when(spyAbstractMinikubeMojo).buildMinikubeCommand(); spyAbstractMinikubeMojo.setCommandExecutorSupplier(() -> mockCommandExecutor); spyAbstractMinikubeMojo.setMavenBuildLogger(mockMavenBuildLogger); spyAbstractMinikubeMojo.execute(); Mockito.verify(mockCommandExecutor).setLogger(mockMavenBuildLogger); Mockito.verify(mockCommandExecutor).run(minikubeCommand); } |
### Question:
CommandExecutor { public List<String> run(String... command) throws IOException, InterruptedException { return run(Arrays.asList(command)); } CommandExecutor setLogger(BuildLogger logger); CommandExecutor setEnvironment(Map<String, String> environmentMap); List<String> run(String... command); List<String> run(List<String> command); }### Answer:
@Test public void testRun_success() throws IOException, InterruptedException { setMockProcessOutput(expectedOutput); List<String> output = testCommandExecutor.run(command); verifyProcessBuilding(command); Assert.assertEquals(expectedOutput, output); Mockito.verifyZeroInteractions(mockBuildLogger); }
@Test public void testRun_commandError() throws InterruptedException, IOException { setMockProcessOutput(expectedOutput); Mockito.when(mockProcess.waitFor()).thenReturn(1); try { testCommandExecutor.run(command); Assert.fail("Expected an IOException to be thrown"); } catch (IOException ex) { Assert.assertEquals("command exited with non-zero exit code : 1", ex.getMessage()); verifyProcessBuilding(command); Mockito.verifyZeroInteractions(mockBuildLogger); } } |
### Question:
MinikubePlugin implements Plugin<Project> { @Override public void apply(Project project) { this.project = project; CommandExecutorFactory commandExecutorFactory = new CommandExecutorFactory(project.getLogger()); createMinikubeExtension(commandExecutorFactory); configureMinikubeTaskAdditionCallback(commandExecutorFactory); createMinikubeStartTask(); createMinikubeStopTask(); createMinikubeDeleteTask(); } @Override void apply(Project project); }### Answer:
@Test public void testDefaultMinikubeTasks() { Project project = ProjectBuilder.builder().withProjectDir(tmp.getRoot()).build(); project.getPluginManager().apply(MinikubePlugin.class); ((ProjectInternal) project).evaluate(); TaskContainer t = project.getTasks(); TaskCollection<MinikubeTask> tc = t.withType(MinikubeTask.class); Assert.assertEquals(3, tc.size()); AssertMinikubeTaskConfig(tc, "minikubeStart", "start"); AssertMinikubeTaskConfig(tc, "minikubeStop", "stop"); AssertMinikubeTaskConfig(tc, "minikubeDelete", "delete"); }
@Test public void testMinikubeExtensionSetProperties() { Project project = ProjectBuilder.builder().withProjectDir(tmp.getRoot()).build(); project.getPluginManager().apply(MinikubePlugin.class); MinikubeExtension ex = (MinikubeExtension) project.getExtensions().getByName("minikube"); ex.setMinikube("/custom/minikube/path"); TaskContainer t = project.getTasks(); TaskCollection<MinikubeTask> tc = t.withType(MinikubeTask.class); Assert.assertEquals(3, tc.size()); tc.forEach( minikubeTask -> { Assert.assertEquals(minikubeTask.getMinikube(), "/custom/minikube/path"); }); }
@Test public void testUserAddedMinikubeTaskConfigured() { Project project = ProjectBuilder.builder().withProjectDir(tmp.getRoot()).build(); project.getPluginManager().apply(MinikubePlugin.class); MinikubeExtension ex = (MinikubeExtension) project.getExtensions().getByName("minikube"); ex.setMinikube("/custom/minikube/path"); MinikubeTask custom = project.getTasks().create("minikubeCustom", MinikubeTask.class); custom.setCommand("custom"); Assert.assertEquals(custom.getMinikube(), "/custom/minikube/path"); Assert.assertEquals(custom.getCommand(), "custom"); Assert.assertArrayEquals(custom.getFlags(), new String[] {}); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.