src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
EndSubscriberHelper { public static boolean validate(Subscription upstream, Subscription next, Class<?> subscriber) { ObjectHelper.requireNonNull(next, "next is null"); if (upstream != null) { next.cancel(); if (upstream != SubscriptionHelper.CANCELLED) { reportDoubleSubscription(subscriber); } return false; } return true; } private EndSubscriberHelper(); static boolean validate(Subscription upstream, Subscription next, Class<?> subscriber); static boolean setOnce(AtomicReference<Subscription> upstream, Subscription next, Class<?> subscriber); static String composeMessage(String consumer); static void reportDoubleSubscription(Class<?> consumer); } | @Test public void validateSubscription() { BooleanSubscription d1 = new BooleanSubscription(); assertFalse(EndSubscriberHelper.validate(SubscriptionHelper.CANCELLED, d1, getClass())); assertTrue(d1.isCancelled()); assertTrue(errors.toString(), errors.isEmpty()); } |
QueueDrainHelper { static boolean isCancelled(BooleanSupplier cancelled) { try { return cancelled.getAsBoolean(); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); return true; } } private QueueDrainHelper(); static void drainMaxLoop(SimplePlainQueue<T> q, Subscriber<? super U> a, boolean delayError,
Disposable dispose, QueueDrain<T, U> qd); static boolean checkTerminated(boolean d, boolean empty,
Subscriber<?> s, boolean delayError, FusedQueue<?> q, QueueDrain<T, U> qd); static FusedQueue<T> createQueue(int capacityHint); static void request(Subscription s, int prefetch); static boolean postCompleteRequest(long n,
Subscriber<? super T> actual,
Queue<T> queue,
AtomicLong state,
BooleanSupplier isCancelled); static void postComplete(Subscriber<? super T> actual,
Queue<T> queue,
AtomicLong state,
BooleanSupplier isCancelled); } | @Test public void isCancelled() { assertTrue(QueueDrainHelper.isCancelled(new BooleanSupplier() { @Override public boolean getAsBoolean() throws Exception { throw new IOException(); } })); } |
QueueDrainHelper { public static void request(Subscription s, int prefetch) { s.request(prefetch < 0 ? Long.MAX_VALUE : prefetch); } private QueueDrainHelper(); static void drainMaxLoop(SimplePlainQueue<T> q, Subscriber<? super U> a, boolean delayError,
Disposable dispose, QueueDrain<T, U> qd); static boolean checkTerminated(boolean d, boolean empty,
Subscriber<?> s, boolean delayError, FusedQueue<?> q, QueueDrain<T, U> qd); static FusedQueue<T> createQueue(int capacityHint); static void request(Subscription s, int prefetch); static boolean postCompleteRequest(long n,
Subscriber<? super T> actual,
Queue<T> queue,
AtomicLong state,
BooleanSupplier isCancelled); static void postComplete(Subscriber<? super T> actual,
Queue<T> queue,
AtomicLong state,
BooleanSupplier isCancelled); } | @Test public void requestMaxInt() { QueueDrainHelper.request(new Subscription() { @Override public void request(long n) { assertEquals(Integer.MAX_VALUE, n); } @Override public void cancel() { } }, Integer.MAX_VALUE); }
@Test public void requestMinInt() { QueueDrainHelper.request(new Subscription() { @Override public void request(long n) { assertEquals(Long.MAX_VALUE, n); } @Override public void cancel() { } }, Integer.MIN_VALUE); }
@Test public void requestAlmostMaxInt() { QueueDrainHelper.request(new Subscription() { @Override public void request(long n) { assertEquals(Integer.MAX_VALUE - 1, n); } @Override public void cancel() { } }, Integer.MAX_VALUE - 1); } |
QueueDrainHelper { public static <T> void postComplete(Subscriber<? super T> actual, Queue<T> queue, AtomicLong state, BooleanSupplier isCancelled) { if (queue.isEmpty()) { actual.onComplete(); return; } if (postCompleteDrain(state.get(), actual, queue, state, isCancelled)) { return; } for (; ; ) { long r = state.get(); if ((r & COMPLETED_MASK) != 0L) { return; } long u = r | COMPLETED_MASK; if (state.compareAndSet(r, u)) { if (r != 0L) { postCompleteDrain(u, actual, queue, state, isCancelled); } return; } } } private QueueDrainHelper(); static void drainMaxLoop(SimplePlainQueue<T> q, Subscriber<? super U> a, boolean delayError,
Disposable dispose, QueueDrain<T, U> qd); static boolean checkTerminated(boolean d, boolean empty,
Subscriber<?> s, boolean delayError, FusedQueue<?> q, QueueDrain<T, U> qd); static FusedQueue<T> createQueue(int capacityHint); static void request(Subscription s, int prefetch); static boolean postCompleteRequest(long n,
Subscriber<? super T> actual,
Queue<T> queue,
AtomicLong state,
BooleanSupplier isCancelled); static void postComplete(Subscriber<? super T> actual,
Queue<T> queue,
AtomicLong state,
BooleanSupplier isCancelled); } | @Test public void postCompleteEmpty() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); ArrayDeque<Integer> queue = new ArrayDeque<Integer>(); AtomicLong state = new AtomicLong(); BooleanSupplier isCancelled = new BooleanSupplier() { @Override public boolean getAsBoolean() throws Exception { return false; } }; ts.onSubscribe(new BooleanSubscription()); QueueDrainHelper.postComplete(ts, queue, state, isCancelled); ts.assertResult(); }
@Test public void postCompleteWithRequest() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); ArrayDeque<Integer> queue = new ArrayDeque<Integer>(); AtomicLong state = new AtomicLong(); BooleanSupplier isCancelled = new BooleanSupplier() { @Override public boolean getAsBoolean() throws Exception { return false; } }; ts.onSubscribe(new BooleanSubscription()); queue.offer(1); state.getAndIncrement(); QueueDrainHelper.postComplete(ts, queue, state, isCancelled); ts.assertResult(1); } |
MaybeToFlowable extends Flowable<T> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } MaybeToFlowable(MaybeSource<T> source); @Override MaybeSource<T> source(); } | @Test public void source() { Maybe<Integer> m = Maybe.just(1); assertSame(m, (((HasUpstreamMaybeSource<?>)toFlowable(m)).source())); } |
Functions { @SuppressWarnings("unchecked") public static <T> Function<T, T> identity() { return (Function<T, T>)IDENTITY; } private Functions(); static Function<Object[], R> toFunction(final BiFunction<? super T1, ? super T2, ? extends R> f); static Function<Object[], R> toFunction(final Function3<T1, T2, T3, R> f); static Function<Object[], R> toFunction(final Function4<T1, T2, T3, T4, R> f); static Function<Object[], R> toFunction(final Function5<T1, T2, T3, T4, T5, R> f); static Function<Object[], R> toFunction(
final Function6<T1, T2, T3, T4, T5, T6, R> f); static Function<Object[], R> toFunction(
final Function7<T1, T2, T3, T4, T5, T6, T7, R> f); static Function<Object[], R> toFunction(
final Function8<T1, T2, T3, T4, T5, T6, T7, T8, R> f); static Function<Object[], R> toFunction(
final Function9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> f); @SuppressWarnings("unchecked") static Function<T, T> identity(); @SuppressWarnings("unchecked") static Consumer<T> emptyConsumer(); @SuppressWarnings("unchecked") static Predicate<T> alwaysTrue(); @SuppressWarnings("unchecked") static Predicate<T> alwaysFalse(); @SuppressWarnings("unchecked") static Callable<T> nullSupplier(); @SuppressWarnings("unchecked") static Comparator<T> naturalOrder(); static Action futureAction(Future<?> future); static Callable<T> justCallable(T value); static Function<T, U> justFunction(U value); static Function<T, U> castFunction(Class<U> target); static Callable<List<T>> createArrayList(int capacity); static Predicate<T> equalsWith(T value); @SuppressWarnings({ "rawtypes", "unchecked" }) static Callable<Set<T>> createHashSet(); static Consumer<T> notificationOnNext(Consumer<? super Notification<T>> onNotification); static Consumer<Throwable> notificationOnError(Consumer<? super Notification<T>> onNotification); static Action notificationOnComplete(Consumer<? super Notification<T>> onNotification); static Consumer<T> actionConsumer(Action action); static Predicate<T> isInstanceOf(Class<U> clazz); static Predicate<T> predicateReverseFor(BooleanSupplier supplier); static Function<T, Timed<T>> timestampWith(TimeUnit unit, Scheduler scheduler); static BiConsumer<Map<K, T>, T> toMapKeySelector(final Function<? super T, ? extends K> keySelector); static BiConsumer<Map<K, V>, T> toMapKeyValueSelector(final Function<? super T, ? extends K> keySelector, final Function<? super T, ? extends V> valueSelector); static BiConsumer<Map<K, Collection<V>>, T> toMultimapKeyValueSelector(
final Function<? super T, ? extends K> keySelector, final Function<? super T, ? extends V> valueSelector,
final Function<? super K, ? extends Collection<? super V>> collectionFactory); @SuppressWarnings("unchecked") static Comparator<T> naturalComparator(); static Function<List<T>, List<T>> listSorter(final Comparator<? super T> comparator); static final Runnable EMPTY_RUNNABLE; static final Action EMPTY_ACTION; static final Consumer<Throwable> ERROR_CONSUMER; static final Consumer<Throwable> ON_ERROR_MISSING; static final LongConsumer EMPTY_LONG_CONSUMER; } | @Test public void identityFunctionToString() { assertEquals("IdentityFunction", Functions.identity().toString()); } |
RxJavaCommonPlugins { public static void lockdown() { lockdown = true; } private RxJavaCommonPlugins(); static void lockdown(); static boolean isLockdown(); static void setFailOnNonBlockingScheduler(boolean enable); static boolean isFailOnNonBlockingScheduler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getComputationSchedulerHandler(); @Nullable static Consumer<? super Throwable> getErrorHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitComputationSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitIoSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitNewThreadSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitSingleSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getIoSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getNewThreadSchedulerHandler(); @Nullable static Function<? super Runnable, ? extends Runnable> getScheduleHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getSingleSchedulerHandler(); @NonNull static Scheduler initComputationScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initIoScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initNewThreadScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initSingleScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler onComputationScheduler(@NonNull Scheduler defaultScheduler); static void onError(@NonNull Throwable error); @NonNull static Scheduler onIoScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Scheduler onNewThreadScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Runnable onSchedule(@NonNull Runnable run); @NonNull static Scheduler onSingleScheduler(@NonNull Scheduler defaultScheduler); static void reset(); static void setComputationSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setErrorHandler(@Nullable Consumer<? super Throwable> handler); static void setInitComputationSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitIoSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitNewThreadSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitSingleSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setIoSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setNewThreadSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setScheduleHandler(@Nullable Function<? super Runnable, ? extends Runnable> handler); static void setSingleSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static boolean onBeforeBlocking(); static void setOnBeforeBlocking(@Nullable BooleanSupplier handler); @Nullable static BooleanSupplier getOnBeforeBlocking(); @NonNull static Scheduler createComputationScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createIoScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createNewThreadScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createSingleScheduler(@NonNull ThreadFactory threadFactory); } | @SuppressWarnings({ "rawtypes" }) @Test public void lockdown() throws Exception { RxJavaCommonPlugins.reset(); RxJavaCommonPlugins.lockdown(); try { assertTrue(RxJavaCommonPlugins.isLockdown()); Consumer a1 = Functions.emptyConsumer(); Callable f0 = new Callable() { @Override public Object call() { return null; } }; Function f1 = Functions.identity(); BiFunction f2 = new BiFunction() { @Override public Object apply(Object t1, Object t2) { return t2; } }; BooleanSupplier bs = new BooleanSupplier() { @Override public boolean getAsBoolean() throws Exception { return true; } }; for (Method m : RxJavaCommonPlugins.class.getMethods()) { if (m.getName().startsWith("set")) { Method getter; Class<?> paramType = m.getParameterTypes()[0]; if (paramType == Boolean.TYPE) { getter = RxJavaCommonPlugins.class.getMethod("is" + m.getName().substring(3)); } else { getter = RxJavaCommonPlugins.class.getMethod("get" + m.getName().substring(3)); } Object before = getter.invoke(null); try { if (paramType.isAssignableFrom(Boolean.TYPE)) { m.invoke(null, true); } else if (paramType.isAssignableFrom(Callable.class)) { m.invoke(null, f0); } else if (paramType.isAssignableFrom(Function.class)) { m.invoke(null, f1); } else if (paramType.isAssignableFrom(Consumer.class)) { m.invoke(null, a1); } else if (paramType.isAssignableFrom(BooleanSupplier.class)) { m.invoke(null, bs); } else { m.invoke(null, f2); } fail("Should have thrown InvocationTargetException(IllegalStateException)"); } catch (InvocationTargetException ex) { if (ex.getCause() instanceof IllegalStateException) { assertEquals("Plugins can't be changed anymore",ex.getCause().getMessage()); } else { fail("Should have thrown InvocationTargetException(IllegalStateException)"); } } Object after = getter.invoke(null); if (paramType.isPrimitive()) { assertEquals(m.toString(), before, after); } else { assertSame(m.toString(), before, after); } } } } finally { RxJavaCommonPlugins.unlock(); RxJavaCommonPlugins.reset(); assertFalse(RxJavaCommonPlugins.isLockdown()); } } |
RxJavaCommonPlugins { @NonNull public static Scheduler initSingleScheduler(@NonNull Callable<Scheduler> defaultScheduler) { ObjectHelper.requireNonNull(defaultScheduler, "Scheduler Callable can't be null"); Function<? super Callable<Scheduler>, ? extends Scheduler> f = onInitSingleHandler; if (f == null) { return callRequireNonNull(defaultScheduler); } return applyRequireNonNull(f, defaultScheduler); } private RxJavaCommonPlugins(); static void lockdown(); static boolean isLockdown(); static void setFailOnNonBlockingScheduler(boolean enable); static boolean isFailOnNonBlockingScheduler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getComputationSchedulerHandler(); @Nullable static Consumer<? super Throwable> getErrorHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitComputationSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitIoSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitNewThreadSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitSingleSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getIoSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getNewThreadSchedulerHandler(); @Nullable static Function<? super Runnable, ? extends Runnable> getScheduleHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getSingleSchedulerHandler(); @NonNull static Scheduler initComputationScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initIoScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initNewThreadScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initSingleScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler onComputationScheduler(@NonNull Scheduler defaultScheduler); static void onError(@NonNull Throwable error); @NonNull static Scheduler onIoScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Scheduler onNewThreadScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Runnable onSchedule(@NonNull Runnable run); @NonNull static Scheduler onSingleScheduler(@NonNull Scheduler defaultScheduler); static void reset(); static void setComputationSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setErrorHandler(@Nullable Consumer<? super Throwable> handler); static void setInitComputationSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitIoSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitNewThreadSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitSingleSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setIoSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setNewThreadSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setScheduleHandler(@Nullable Function<? super Runnable, ? extends Runnable> handler); static void setSingleSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static boolean onBeforeBlocking(); static void setOnBeforeBlocking(@Nullable BooleanSupplier handler); @Nullable static BooleanSupplier getOnBeforeBlocking(); @NonNull static Scheduler createComputationScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createIoScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createNewThreadScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createSingleScheduler(@NonNull ThreadFactory threadFactory); } | @Test public void overrideInitSingleSchedulerCrashes() { try { RxJavaCommonPlugins.initSingleScheduler(null); fail("Should have thrown NullPointerException"); } catch (NullPointerException npe) { assertEquals("Scheduler Callable can't be null", npe.getMessage()); } try { RxJavaCommonPlugins.initSingleScheduler(nullResultCallable); fail("Should have thrown NullPointerException"); } catch (NullPointerException npe) { assertEquals("Scheduler Callable result can't be null", npe.getMessage()); } } |
RxJavaCommonPlugins { @NonNull public static Scheduler initComputationScheduler(@NonNull Callable<Scheduler> defaultScheduler) { ObjectHelper.requireNonNull(defaultScheduler, "Scheduler Callable can't be null"); Function<? super Callable<Scheduler>, ? extends Scheduler> f = onInitComputationHandler; if (f == null) { return callRequireNonNull(defaultScheduler); } return applyRequireNonNull(f, defaultScheduler); } private RxJavaCommonPlugins(); static void lockdown(); static boolean isLockdown(); static void setFailOnNonBlockingScheduler(boolean enable); static boolean isFailOnNonBlockingScheduler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getComputationSchedulerHandler(); @Nullable static Consumer<? super Throwable> getErrorHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitComputationSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitIoSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitNewThreadSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitSingleSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getIoSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getNewThreadSchedulerHandler(); @Nullable static Function<? super Runnable, ? extends Runnable> getScheduleHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getSingleSchedulerHandler(); @NonNull static Scheduler initComputationScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initIoScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initNewThreadScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initSingleScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler onComputationScheduler(@NonNull Scheduler defaultScheduler); static void onError(@NonNull Throwable error); @NonNull static Scheduler onIoScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Scheduler onNewThreadScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Runnable onSchedule(@NonNull Runnable run); @NonNull static Scheduler onSingleScheduler(@NonNull Scheduler defaultScheduler); static void reset(); static void setComputationSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setErrorHandler(@Nullable Consumer<? super Throwable> handler); static void setInitComputationSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitIoSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitNewThreadSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitSingleSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setIoSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setNewThreadSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setScheduleHandler(@Nullable Function<? super Runnable, ? extends Runnable> handler); static void setSingleSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static boolean onBeforeBlocking(); static void setOnBeforeBlocking(@Nullable BooleanSupplier handler); @Nullable static BooleanSupplier getOnBeforeBlocking(); @NonNull static Scheduler createComputationScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createIoScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createNewThreadScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createSingleScheduler(@NonNull ThreadFactory threadFactory); } | @Test public void overrideInitComputationSchedulerCrashes() { try { RxJavaCommonPlugins.initComputationScheduler(null); fail("Should have thrown NullPointerException"); } catch (NullPointerException npe) { assertEquals("Scheduler Callable can't be null", npe.getMessage()); } try { RxJavaCommonPlugins.initComputationScheduler(nullResultCallable); fail("Should have thrown NullPointerException"); } catch (NullPointerException npe) { assertEquals("Scheduler Callable result can't be null", npe.getMessage()); } } |
RxJavaCommonPlugins { @NonNull public static Scheduler initIoScheduler(@NonNull Callable<Scheduler> defaultScheduler) { ObjectHelper.requireNonNull(defaultScheduler, "Scheduler Callable can't be null"); Function<? super Callable<Scheduler>, ? extends Scheduler> f = onInitIoHandler; if (f == null) { return callRequireNonNull(defaultScheduler); } return applyRequireNonNull(f, defaultScheduler); } private RxJavaCommonPlugins(); static void lockdown(); static boolean isLockdown(); static void setFailOnNonBlockingScheduler(boolean enable); static boolean isFailOnNonBlockingScheduler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getComputationSchedulerHandler(); @Nullable static Consumer<? super Throwable> getErrorHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitComputationSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitIoSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitNewThreadSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitSingleSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getIoSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getNewThreadSchedulerHandler(); @Nullable static Function<? super Runnable, ? extends Runnable> getScheduleHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getSingleSchedulerHandler(); @NonNull static Scheduler initComputationScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initIoScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initNewThreadScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initSingleScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler onComputationScheduler(@NonNull Scheduler defaultScheduler); static void onError(@NonNull Throwable error); @NonNull static Scheduler onIoScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Scheduler onNewThreadScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Runnable onSchedule(@NonNull Runnable run); @NonNull static Scheduler onSingleScheduler(@NonNull Scheduler defaultScheduler); static void reset(); static void setComputationSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setErrorHandler(@Nullable Consumer<? super Throwable> handler); static void setInitComputationSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitIoSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitNewThreadSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitSingleSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setIoSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setNewThreadSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setScheduleHandler(@Nullable Function<? super Runnable, ? extends Runnable> handler); static void setSingleSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static boolean onBeforeBlocking(); static void setOnBeforeBlocking(@Nullable BooleanSupplier handler); @Nullable static BooleanSupplier getOnBeforeBlocking(); @NonNull static Scheduler createComputationScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createIoScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createNewThreadScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createSingleScheduler(@NonNull ThreadFactory threadFactory); } | @Test public void overrideInitIoSchedulerCrashes() { try { RxJavaCommonPlugins.initIoScheduler(null); fail("Should have thrown NullPointerException"); } catch (NullPointerException npe) { assertEquals("Scheduler Callable can't be null", npe.getMessage()); } try { RxJavaCommonPlugins.initIoScheduler(nullResultCallable); fail("Should have thrown NullPointerException"); } catch (NullPointerException npe) { assertEquals("Scheduler Callable result can't be null", npe.getMessage()); } } |
RxJavaCommonPlugins { @NonNull public static Scheduler initNewThreadScheduler(@NonNull Callable<Scheduler> defaultScheduler) { ObjectHelper.requireNonNull(defaultScheduler, "Scheduler Callable can't be null"); Function<? super Callable<Scheduler>, ? extends Scheduler> f = onInitNewThreadHandler; if (f == null) { return callRequireNonNull(defaultScheduler); } return applyRequireNonNull(f, defaultScheduler); } private RxJavaCommonPlugins(); static void lockdown(); static boolean isLockdown(); static void setFailOnNonBlockingScheduler(boolean enable); static boolean isFailOnNonBlockingScheduler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getComputationSchedulerHandler(); @Nullable static Consumer<? super Throwable> getErrorHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitComputationSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitIoSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitNewThreadSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitSingleSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getIoSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getNewThreadSchedulerHandler(); @Nullable static Function<? super Runnable, ? extends Runnable> getScheduleHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getSingleSchedulerHandler(); @NonNull static Scheduler initComputationScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initIoScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initNewThreadScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initSingleScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler onComputationScheduler(@NonNull Scheduler defaultScheduler); static void onError(@NonNull Throwable error); @NonNull static Scheduler onIoScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Scheduler onNewThreadScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Runnable onSchedule(@NonNull Runnable run); @NonNull static Scheduler onSingleScheduler(@NonNull Scheduler defaultScheduler); static void reset(); static void setComputationSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setErrorHandler(@Nullable Consumer<? super Throwable> handler); static void setInitComputationSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitIoSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitNewThreadSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitSingleSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setIoSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setNewThreadSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setScheduleHandler(@Nullable Function<? super Runnable, ? extends Runnable> handler); static void setSingleSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static boolean onBeforeBlocking(); static void setOnBeforeBlocking(@Nullable BooleanSupplier handler); @Nullable static BooleanSupplier getOnBeforeBlocking(); @NonNull static Scheduler createComputationScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createIoScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createNewThreadScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createSingleScheduler(@NonNull ThreadFactory threadFactory); } | @Test public void overrideInitNewThreadSchedulerCrashes() { try { RxJavaCommonPlugins.initNewThreadScheduler(null); fail("Should have thrown NullPointerException"); } catch (NullPointerException npe) { assertEquals("Scheduler Callable can't be null", npe.getMessage()); } try { RxJavaCommonPlugins.initNewThreadScheduler(nullResultCallable); fail("Should have thrown NullPointerException"); } catch (NullPointerException npe) { assertEquals("Scheduler Callable result can't be null", npe.getMessage()); } } |
RxJavaCommonPlugins { @NonNull public static Runnable onSchedule(@NonNull Runnable run) { Function<? super Runnable, ? extends Runnable> f = onScheduleHandler; if (f == null) { return run; } return apply(f, run); } private RxJavaCommonPlugins(); static void lockdown(); static boolean isLockdown(); static void setFailOnNonBlockingScheduler(boolean enable); static boolean isFailOnNonBlockingScheduler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getComputationSchedulerHandler(); @Nullable static Consumer<? super Throwable> getErrorHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitComputationSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitIoSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitNewThreadSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitSingleSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getIoSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getNewThreadSchedulerHandler(); @Nullable static Function<? super Runnable, ? extends Runnable> getScheduleHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getSingleSchedulerHandler(); @NonNull static Scheduler initComputationScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initIoScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initNewThreadScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initSingleScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler onComputationScheduler(@NonNull Scheduler defaultScheduler); static void onError(@NonNull Throwable error); @NonNull static Scheduler onIoScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Scheduler onNewThreadScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Runnable onSchedule(@NonNull Runnable run); @NonNull static Scheduler onSingleScheduler(@NonNull Scheduler defaultScheduler); static void reset(); static void setComputationSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setErrorHandler(@Nullable Consumer<? super Throwable> handler); static void setInitComputationSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitIoSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitNewThreadSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitSingleSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setIoSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setNewThreadSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setScheduleHandler(@Nullable Function<? super Runnable, ? extends Runnable> handler); static void setSingleSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static boolean onBeforeBlocking(); static void setOnBeforeBlocking(@Nullable BooleanSupplier handler); @Nullable static BooleanSupplier getOnBeforeBlocking(); @NonNull static Scheduler createComputationScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createIoScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createNewThreadScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createSingleScheduler(@NonNull ThreadFactory threadFactory); } | @Test public void onScheduleComputation() throws InterruptedException { onSchedule(Schedulers.computation().createWorker()); }
@Test public void onScheduleIO() throws InterruptedException { onSchedule(Schedulers.io().createWorker()); }
@Test public void onScheduleNewThread() throws InterruptedException { onSchedule(Schedulers.newThread().createWorker()); } |
RxJavaCommonPlugins { public static void onError(@NonNull Throwable error) { Consumer<? super Throwable> f = errorHandler; if (error == null) { error = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources."); } else { if (!isBug(error)) { error = new UndeliverableException(error); } } if (f != null) { try { f.accept(error); return; } catch (Throwable e) { e.printStackTrace(); uncaught(e); } } error.printStackTrace(); uncaught(error); } private RxJavaCommonPlugins(); static void lockdown(); static boolean isLockdown(); static void setFailOnNonBlockingScheduler(boolean enable); static boolean isFailOnNonBlockingScheduler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getComputationSchedulerHandler(); @Nullable static Consumer<? super Throwable> getErrorHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitComputationSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitIoSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitNewThreadSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitSingleSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getIoSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getNewThreadSchedulerHandler(); @Nullable static Function<? super Runnable, ? extends Runnable> getScheduleHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getSingleSchedulerHandler(); @NonNull static Scheduler initComputationScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initIoScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initNewThreadScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initSingleScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler onComputationScheduler(@NonNull Scheduler defaultScheduler); static void onError(@NonNull Throwable error); @NonNull static Scheduler onIoScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Scheduler onNewThreadScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Runnable onSchedule(@NonNull Runnable run); @NonNull static Scheduler onSingleScheduler(@NonNull Scheduler defaultScheduler); static void reset(); static void setComputationSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setErrorHandler(@Nullable Consumer<? super Throwable> handler); static void setInitComputationSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitIoSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitNewThreadSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitSingleSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setIoSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setNewThreadSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setScheduleHandler(@Nullable Function<? super Runnable, ? extends Runnable> handler); static void setSingleSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static boolean onBeforeBlocking(); static void setOnBeforeBlocking(@Nullable BooleanSupplier handler); @Nullable static BooleanSupplier getOnBeforeBlocking(); @NonNull static Scheduler createComputationScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createIoScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createNewThreadScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createSingleScheduler(@NonNull ThreadFactory threadFactory); } | @Test public void onError() { try { final List<Throwable> list = new ArrayList<Throwable>(); RxJavaCommonPlugins.setErrorHandler(new Consumer<Throwable>() { @Override public void accept(Throwable t) { list.add(t); } }); RxJavaCommonPlugins.onError(new TestException("Forced failure")); assertEquals(1, list.size()); assertUndeliverableTestException(list, 0, "Forced failure"); } finally { RxJavaCommonPlugins.reset(); } } |
RxJavaCommonPlugins { @NonNull public static Scheduler createComputationScheduler(@NonNull ThreadFactory threadFactory) { return new ComputationScheduler(ObjectHelper.requireNonNull(threadFactory, "threadFactory is null")); } private RxJavaCommonPlugins(); static void lockdown(); static boolean isLockdown(); static void setFailOnNonBlockingScheduler(boolean enable); static boolean isFailOnNonBlockingScheduler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getComputationSchedulerHandler(); @Nullable static Consumer<? super Throwable> getErrorHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitComputationSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitIoSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitNewThreadSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitSingleSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getIoSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getNewThreadSchedulerHandler(); @Nullable static Function<? super Runnable, ? extends Runnable> getScheduleHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getSingleSchedulerHandler(); @NonNull static Scheduler initComputationScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initIoScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initNewThreadScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initSingleScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler onComputationScheduler(@NonNull Scheduler defaultScheduler); static void onError(@NonNull Throwable error); @NonNull static Scheduler onIoScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Scheduler onNewThreadScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Runnable onSchedule(@NonNull Runnable run); @NonNull static Scheduler onSingleScheduler(@NonNull Scheduler defaultScheduler); static void reset(); static void setComputationSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setErrorHandler(@Nullable Consumer<? super Throwable> handler); static void setInitComputationSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitIoSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitNewThreadSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitSingleSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setIoSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setNewThreadSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setScheduleHandler(@Nullable Function<? super Runnable, ? extends Runnable> handler); static void setSingleSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static boolean onBeforeBlocking(); static void setOnBeforeBlocking(@Nullable BooleanSupplier handler); @Nullable static BooleanSupplier getOnBeforeBlocking(); @NonNull static Scheduler createComputationScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createIoScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createNewThreadScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createSingleScheduler(@NonNull ThreadFactory threadFactory); } | @Test public void createComputationScheduler() { final String name = "ComputationSchedulerTest"; ThreadFactory factory = new ThreadFactory() { @Override public Thread newThread(Runnable r) { return new Thread(r, name); } }; final Scheduler customScheduler = RxJavaCommonPlugins.createComputationScheduler(factory); RxJavaCommonPlugins.setComputationSchedulerHandler(new Function<Scheduler, Scheduler>() { @Override public Scheduler apply(Scheduler scheduler) throws Exception { return customScheduler; } }); try { verifyThread(Schedulers.computation(), name); } finally { customScheduler.shutdown(); RxJavaCommonPlugins.reset(); } } |
RxJavaCommonPlugins { @NonNull public static Scheduler createIoScheduler(@NonNull ThreadFactory threadFactory) { return new IoScheduler(ObjectHelper.requireNonNull(threadFactory, "threadFactory is null")); } private RxJavaCommonPlugins(); static void lockdown(); static boolean isLockdown(); static void setFailOnNonBlockingScheduler(boolean enable); static boolean isFailOnNonBlockingScheduler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getComputationSchedulerHandler(); @Nullable static Consumer<? super Throwable> getErrorHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitComputationSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitIoSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitNewThreadSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitSingleSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getIoSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getNewThreadSchedulerHandler(); @Nullable static Function<? super Runnable, ? extends Runnable> getScheduleHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getSingleSchedulerHandler(); @NonNull static Scheduler initComputationScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initIoScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initNewThreadScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initSingleScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler onComputationScheduler(@NonNull Scheduler defaultScheduler); static void onError(@NonNull Throwable error); @NonNull static Scheduler onIoScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Scheduler onNewThreadScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Runnable onSchedule(@NonNull Runnable run); @NonNull static Scheduler onSingleScheduler(@NonNull Scheduler defaultScheduler); static void reset(); static void setComputationSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setErrorHandler(@Nullable Consumer<? super Throwable> handler); static void setInitComputationSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitIoSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitNewThreadSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitSingleSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setIoSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setNewThreadSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setScheduleHandler(@Nullable Function<? super Runnable, ? extends Runnable> handler); static void setSingleSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static boolean onBeforeBlocking(); static void setOnBeforeBlocking(@Nullable BooleanSupplier handler); @Nullable static BooleanSupplier getOnBeforeBlocking(); @NonNull static Scheduler createComputationScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createIoScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createNewThreadScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createSingleScheduler(@NonNull ThreadFactory threadFactory); } | @Test public void createIoScheduler() { final String name = "IoSchedulerTest"; ThreadFactory factory = new ThreadFactory() { @Override public Thread newThread(Runnable r) { return new Thread(r, name); } }; final Scheduler customScheduler = RxJavaCommonPlugins.createIoScheduler(factory); RxJavaCommonPlugins.setIoSchedulerHandler(new Function<Scheduler, Scheduler>() { @Override public Scheduler apply(Scheduler scheduler) throws Exception { return customScheduler; } }); try { verifyThread(Schedulers.io(), name); } finally { customScheduler.shutdown(); RxJavaCommonPlugins.reset(); } } |
RxJavaCommonPlugins { @NonNull public static Scheduler createNewThreadScheduler(@NonNull ThreadFactory threadFactory) { return new NewThreadScheduler(ObjectHelper.requireNonNull(threadFactory, "threadFactory is null")); } private RxJavaCommonPlugins(); static void lockdown(); static boolean isLockdown(); static void setFailOnNonBlockingScheduler(boolean enable); static boolean isFailOnNonBlockingScheduler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getComputationSchedulerHandler(); @Nullable static Consumer<? super Throwable> getErrorHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitComputationSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitIoSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitNewThreadSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitSingleSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getIoSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getNewThreadSchedulerHandler(); @Nullable static Function<? super Runnable, ? extends Runnable> getScheduleHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getSingleSchedulerHandler(); @NonNull static Scheduler initComputationScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initIoScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initNewThreadScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initSingleScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler onComputationScheduler(@NonNull Scheduler defaultScheduler); static void onError(@NonNull Throwable error); @NonNull static Scheduler onIoScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Scheduler onNewThreadScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Runnable onSchedule(@NonNull Runnable run); @NonNull static Scheduler onSingleScheduler(@NonNull Scheduler defaultScheduler); static void reset(); static void setComputationSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setErrorHandler(@Nullable Consumer<? super Throwable> handler); static void setInitComputationSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitIoSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitNewThreadSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitSingleSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setIoSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setNewThreadSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setScheduleHandler(@Nullable Function<? super Runnable, ? extends Runnable> handler); static void setSingleSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static boolean onBeforeBlocking(); static void setOnBeforeBlocking(@Nullable BooleanSupplier handler); @Nullable static BooleanSupplier getOnBeforeBlocking(); @NonNull static Scheduler createComputationScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createIoScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createNewThreadScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createSingleScheduler(@NonNull ThreadFactory threadFactory); } | @Test public void createNewThreadScheduler() { final String name = "NewThreadSchedulerTest"; ThreadFactory factory = new ThreadFactory() { @Override public Thread newThread(Runnable r) { return new Thread(r, name); } }; final Scheduler customScheduler = RxJavaCommonPlugins.createNewThreadScheduler(factory); RxJavaCommonPlugins.setNewThreadSchedulerHandler(new Function<Scheduler, Scheduler>() { @Override public Scheduler apply(Scheduler scheduler) throws Exception { return customScheduler; } }); try { verifyThread(Schedulers.newThread(), name); } finally { customScheduler.shutdown(); RxJavaCommonPlugins.reset(); } } |
PixabayImage { public int getPreviewHeight() { return previewHeight; } PixabayImage(int previewHeight, int likes, int favorites, String tags,
int webformatHeight, long views, int webformatWidth, int previewWidth,
int comments, long downloads, String pageURL, String previewURL,
String webformatURL, int imageWidth, long userId, String user,
PixabayImageType type, long id, String userImageURL, int imageHeight); int getPreviewHeight(); String getLikes(); String getFavorites(); String getTags(); int getWebformatHeight(); long getViews(); int getWebformatWidth(); int getPreviewWidth(); String getComments(); long getDownloads(); String getPageURL(); String getPreviewURL(); String getWebformatURL(); int getImageWidth(); long getUserId(); String getUser(); PixabayImageType getType(); long getId(); String getUserImageURL(); int getImageHeight(); } | @Test public void getPreviewHeight() throws Exception { assertEquals(pixabayImage.getPreviewHeight(), 180); } |
PixabayImage { public String getPageURL() { return pageURL; } PixabayImage(int previewHeight, int likes, int favorites, String tags,
int webformatHeight, long views, int webformatWidth, int previewWidth,
int comments, long downloads, String pageURL, String previewURL,
String webformatURL, int imageWidth, long userId, String user,
PixabayImageType type, long id, String userImageURL, int imageHeight); int getPreviewHeight(); String getLikes(); String getFavorites(); String getTags(); int getWebformatHeight(); long getViews(); int getWebformatWidth(); int getPreviewWidth(); String getComments(); long getDownloads(); String getPageURL(); String getPreviewURL(); String getWebformatURL(); int getImageWidth(); long getUserId(); String getUser(); PixabayImageType getType(); long getId(); String getUserImageURL(); int getImageHeight(); } | @Test public void getPageURL() throws Exception { assertEquals(pixabayImage.getPageURL(), "http: } |
PixabayImage { public String getPreviewURL() { return previewURL; } PixabayImage(int previewHeight, int likes, int favorites, String tags,
int webformatHeight, long views, int webformatWidth, int previewWidth,
int comments, long downloads, String pageURL, String previewURL,
String webformatURL, int imageWidth, long userId, String user,
PixabayImageType type, long id, String userImageURL, int imageHeight); int getPreviewHeight(); String getLikes(); String getFavorites(); String getTags(); int getWebformatHeight(); long getViews(); int getWebformatWidth(); int getPreviewWidth(); String getComments(); long getDownloads(); String getPageURL(); String getPreviewURL(); String getWebformatURL(); int getImageWidth(); long getUserId(); String getUser(); PixabayImageType getType(); long getId(); String getUserImageURL(); int getImageHeight(); } | @Test public void getPreviewURL() throws Exception { assertEquals(pixabayImage.getPreviewURL(), "http: } |
PixabayImage { public String getWebformatURL() { return webformatURL; } PixabayImage(int previewHeight, int likes, int favorites, String tags,
int webformatHeight, long views, int webformatWidth, int previewWidth,
int comments, long downloads, String pageURL, String previewURL,
String webformatURL, int imageWidth, long userId, String user,
PixabayImageType type, long id, String userImageURL, int imageHeight); int getPreviewHeight(); String getLikes(); String getFavorites(); String getTags(); int getWebformatHeight(); long getViews(); int getWebformatWidth(); int getPreviewWidth(); String getComments(); long getDownloads(); String getPageURL(); String getPreviewURL(); String getWebformatURL(); int getImageWidth(); long getUserId(); String getUser(); PixabayImageType getType(); long getId(); String getUserImageURL(); int getImageHeight(); } | @Test public void getWebformatURL() throws Exception { assertEquals(pixabayImage.getWebformatURL(), "http: } |
PixabayImage { public int getImageWidth() { return imageWidth; } PixabayImage(int previewHeight, int likes, int favorites, String tags,
int webformatHeight, long views, int webformatWidth, int previewWidth,
int comments, long downloads, String pageURL, String previewURL,
String webformatURL, int imageWidth, long userId, String user,
PixabayImageType type, long id, String userImageURL, int imageHeight); int getPreviewHeight(); String getLikes(); String getFavorites(); String getTags(); int getWebformatHeight(); long getViews(); int getWebformatWidth(); int getPreviewWidth(); String getComments(); long getDownloads(); String getPageURL(); String getPreviewURL(); String getWebformatURL(); int getImageWidth(); long getUserId(); String getUser(); PixabayImageType getType(); long getId(); String getUserImageURL(); int getImageHeight(); } | @Test public void getImageWidth() throws Exception { assertEquals(pixabayImage.getImageWidth(), 1080); } |
PixabayImage { public long getUserId() { return userId; } PixabayImage(int previewHeight, int likes, int favorites, String tags,
int webformatHeight, long views, int webformatWidth, int previewWidth,
int comments, long downloads, String pageURL, String previewURL,
String webformatURL, int imageWidth, long userId, String user,
PixabayImageType type, long id, String userImageURL, int imageHeight); int getPreviewHeight(); String getLikes(); String getFavorites(); String getTags(); int getWebformatHeight(); long getViews(); int getWebformatWidth(); int getPreviewWidth(); String getComments(); long getDownloads(); String getPageURL(); String getPreviewURL(); String getWebformatURL(); int getImageWidth(); long getUserId(); String getUser(); PixabayImageType getType(); long getId(); String getUserImageURL(); int getImageHeight(); } | @Test public void getUserId() throws Exception { assertEquals(pixabayImage.getUserId(), 123456); } |
PixabayImage { public String getUser() { return "By: " + user; } PixabayImage(int previewHeight, int likes, int favorites, String tags,
int webformatHeight, long views, int webformatWidth, int previewWidth,
int comments, long downloads, String pageURL, String previewURL,
String webformatURL, int imageWidth, long userId, String user,
PixabayImageType type, long id, String userImageURL, int imageHeight); int getPreviewHeight(); String getLikes(); String getFavorites(); String getTags(); int getWebformatHeight(); long getViews(); int getWebformatWidth(); int getPreviewWidth(); String getComments(); long getDownloads(); String getPageURL(); String getPreviewURL(); String getWebformatURL(); int getImageWidth(); long getUserId(); String getUser(); PixabayImageType getType(); long getId(); String getUserImageURL(); int getImageHeight(); } | @Test public void getUser() throws Exception { assertEquals(pixabayImage.getUser(), "By: user"); } |
PixabayImage { public PixabayImageType getType() { return type; } PixabayImage(int previewHeight, int likes, int favorites, String tags,
int webformatHeight, long views, int webformatWidth, int previewWidth,
int comments, long downloads, String pageURL, String previewURL,
String webformatURL, int imageWidth, long userId, String user,
PixabayImageType type, long id, String userImageURL, int imageHeight); int getPreviewHeight(); String getLikes(); String getFavorites(); String getTags(); int getWebformatHeight(); long getViews(); int getWebformatWidth(); int getPreviewWidth(); String getComments(); long getDownloads(); String getPageURL(); String getPreviewURL(); String getWebformatURL(); int getImageWidth(); long getUserId(); String getUser(); PixabayImageType getType(); long getId(); String getUserImageURL(); int getImageHeight(); } | @Test public void getType() throws Exception { assertEquals(pixabayImage.getType(), PixabayImageType.illustration); } |
PixabayImage { public long getId() { return id; } PixabayImage(int previewHeight, int likes, int favorites, String tags,
int webformatHeight, long views, int webformatWidth, int previewWidth,
int comments, long downloads, String pageURL, String previewURL,
String webformatURL, int imageWidth, long userId, String user,
PixabayImageType type, long id, String userImageURL, int imageHeight); int getPreviewHeight(); String getLikes(); String getFavorites(); String getTags(); int getWebformatHeight(); long getViews(); int getWebformatWidth(); int getPreviewWidth(); String getComments(); long getDownloads(); String getPageURL(); String getPreviewURL(); String getWebformatURL(); int getImageWidth(); long getUserId(); String getUser(); PixabayImageType getType(); long getId(); String getUserImageURL(); int getImageHeight(); } | @Test public void getId() throws Exception { assertEquals(pixabayImage.getId(), 987654); } |
PixabayImage { public String getUserImageURL() { return userImageURL; } PixabayImage(int previewHeight, int likes, int favorites, String tags,
int webformatHeight, long views, int webformatWidth, int previewWidth,
int comments, long downloads, String pageURL, String previewURL,
String webformatURL, int imageWidth, long userId, String user,
PixabayImageType type, long id, String userImageURL, int imageHeight); int getPreviewHeight(); String getLikes(); String getFavorites(); String getTags(); int getWebformatHeight(); long getViews(); int getWebformatWidth(); int getPreviewWidth(); String getComments(); long getDownloads(); String getPageURL(); String getPreviewURL(); String getWebformatURL(); int getImageWidth(); long getUserId(); String getUser(); PixabayImageType getType(); long getId(); String getUserImageURL(); int getImageHeight(); } | @Test public void getUserImageURL() throws Exception { assertEquals(pixabayImage.getUserImageURL(), "http: } |
PixabayImage { public int getImageHeight() { return imageHeight; } PixabayImage(int previewHeight, int likes, int favorites, String tags,
int webformatHeight, long views, int webformatWidth, int previewWidth,
int comments, long downloads, String pageURL, String previewURL,
String webformatURL, int imageWidth, long userId, String user,
PixabayImageType type, long id, String userImageURL, int imageHeight); int getPreviewHeight(); String getLikes(); String getFavorites(); String getTags(); int getWebformatHeight(); long getViews(); int getWebformatWidth(); int getPreviewWidth(); String getComments(); long getDownloads(); String getPageURL(); String getPreviewURL(); String getWebformatURL(); int getImageWidth(); long getUserId(); String getUser(); PixabayImageType getType(); long getId(); String getUserImageURL(); int getImageHeight(); } | @Test public void getImageHeight() throws Exception { assertEquals(pixabayImage.getImageHeight(), 1024); } |
PixabayImage { public String getLikes() { return String.valueOf(likes); } PixabayImage(int previewHeight, int likes, int favorites, String tags,
int webformatHeight, long views, int webformatWidth, int previewWidth,
int comments, long downloads, String pageURL, String previewURL,
String webformatURL, int imageWidth, long userId, String user,
PixabayImageType type, long id, String userImageURL, int imageHeight); int getPreviewHeight(); String getLikes(); String getFavorites(); String getTags(); int getWebformatHeight(); long getViews(); int getWebformatWidth(); int getPreviewWidth(); String getComments(); long getDownloads(); String getPageURL(); String getPreviewURL(); String getWebformatURL(); int getImageWidth(); long getUserId(); String getUser(); PixabayImageType getType(); long getId(); String getUserImageURL(); int getImageHeight(); } | @Test public void getLikes() throws Exception { assertEquals(pixabayImage.getLikes(), "100"); } |
PixabayImage { public String getFavorites() { return String.valueOf(favorites); } PixabayImage(int previewHeight, int likes, int favorites, String tags,
int webformatHeight, long views, int webformatWidth, int previewWidth,
int comments, long downloads, String pageURL, String previewURL,
String webformatURL, int imageWidth, long userId, String user,
PixabayImageType type, long id, String userImageURL, int imageHeight); int getPreviewHeight(); String getLikes(); String getFavorites(); String getTags(); int getWebformatHeight(); long getViews(); int getWebformatWidth(); int getPreviewWidth(); String getComments(); long getDownloads(); String getPageURL(); String getPreviewURL(); String getWebformatURL(); int getImageWidth(); long getUserId(); String getUser(); PixabayImageType getType(); long getId(); String getUserImageURL(); int getImageHeight(); } | @Test public void getFavorites() throws Exception { assertEquals(pixabayImage.getFavorites(), "50"); } |
PixabayImage { public String getTags() { if (tags == null) return ""; if (tags.contains(", ")) { String[] splitTags = tags.toUpperCase().split(", "); return TextUtils.join(" - ", splitTags); } else return tags; } PixabayImage(int previewHeight, int likes, int favorites, String tags,
int webformatHeight, long views, int webformatWidth, int previewWidth,
int comments, long downloads, String pageURL, String previewURL,
String webformatURL, int imageWidth, long userId, String user,
PixabayImageType type, long id, String userImageURL, int imageHeight); int getPreviewHeight(); String getLikes(); String getFavorites(); String getTags(); int getWebformatHeight(); long getViews(); int getWebformatWidth(); int getPreviewWidth(); String getComments(); long getDownloads(); String getPageURL(); String getPreviewURL(); String getWebformatURL(); int getImageWidth(); long getUserId(); String getUser(); PixabayImageType getType(); long getId(); String getUserImageURL(); int getImageHeight(); } | @Test public void getTags() throws Exception { assertEquals(pixabayImage.getTags(), null); } |
PixabayImage { public int getWebformatHeight() { return webformatHeight; } PixabayImage(int previewHeight, int likes, int favorites, String tags,
int webformatHeight, long views, int webformatWidth, int previewWidth,
int comments, long downloads, String pageURL, String previewURL,
String webformatURL, int imageWidth, long userId, String user,
PixabayImageType type, long id, String userImageURL, int imageHeight); int getPreviewHeight(); String getLikes(); String getFavorites(); String getTags(); int getWebformatHeight(); long getViews(); int getWebformatWidth(); int getPreviewWidth(); String getComments(); long getDownloads(); String getPageURL(); String getPreviewURL(); String getWebformatURL(); int getImageWidth(); long getUserId(); String getUser(); PixabayImageType getType(); long getId(); String getUserImageURL(); int getImageHeight(); } | @Test public void getWebformatHeight() throws Exception { assertEquals(pixabayImage.getWebformatHeight(), 90); } |
PixabayImage { public long getViews() { return views; } PixabayImage(int previewHeight, int likes, int favorites, String tags,
int webformatHeight, long views, int webformatWidth, int previewWidth,
int comments, long downloads, String pageURL, String previewURL,
String webformatURL, int imageWidth, long userId, String user,
PixabayImageType type, long id, String userImageURL, int imageHeight); int getPreviewHeight(); String getLikes(); String getFavorites(); String getTags(); int getWebformatHeight(); long getViews(); int getWebformatWidth(); int getPreviewWidth(); String getComments(); long getDownloads(); String getPageURL(); String getPreviewURL(); String getWebformatURL(); int getImageWidth(); long getUserId(); String getUser(); PixabayImageType getType(); long getId(); String getUserImageURL(); int getImageHeight(); } | @Test public void getViews() throws Exception { assertEquals(pixabayImage.getViews(), 1234); } |
PixabayImage { public int getWebformatWidth() { return webformatWidth; } PixabayImage(int previewHeight, int likes, int favorites, String tags,
int webformatHeight, long views, int webformatWidth, int previewWidth,
int comments, long downloads, String pageURL, String previewURL,
String webformatURL, int imageWidth, long userId, String user,
PixabayImageType type, long id, String userImageURL, int imageHeight); int getPreviewHeight(); String getLikes(); String getFavorites(); String getTags(); int getWebformatHeight(); long getViews(); int getWebformatWidth(); int getPreviewWidth(); String getComments(); long getDownloads(); String getPageURL(); String getPreviewURL(); String getWebformatURL(); int getImageWidth(); long getUserId(); String getUser(); PixabayImageType getType(); long getId(); String getUserImageURL(); int getImageHeight(); } | @Test public void getWebformatWidth() throws Exception { assertEquals(pixabayImage.getWebformatWidth(), 360); } |
PixabayImage { public int getPreviewWidth() { return previewWidth; } PixabayImage(int previewHeight, int likes, int favorites, String tags,
int webformatHeight, long views, int webformatWidth, int previewWidth,
int comments, long downloads, String pageURL, String previewURL,
String webformatURL, int imageWidth, long userId, String user,
PixabayImageType type, long id, String userImageURL, int imageHeight); int getPreviewHeight(); String getLikes(); String getFavorites(); String getTags(); int getWebformatHeight(); long getViews(); int getWebformatWidth(); int getPreviewWidth(); String getComments(); long getDownloads(); String getPageURL(); String getPreviewURL(); String getWebformatURL(); int getImageWidth(); long getUserId(); String getUser(); PixabayImageType getType(); long getId(); String getUserImageURL(); int getImageHeight(); } | @Test public void getPreviewWidth() throws Exception { assertEquals(pixabayImage.getPreviewWidth(), 180); } |
PixabayImage { public String getComments() { return String.valueOf(comments); } PixabayImage(int previewHeight, int likes, int favorites, String tags,
int webformatHeight, long views, int webformatWidth, int previewWidth,
int comments, long downloads, String pageURL, String previewURL,
String webformatURL, int imageWidth, long userId, String user,
PixabayImageType type, long id, String userImageURL, int imageHeight); int getPreviewHeight(); String getLikes(); String getFavorites(); String getTags(); int getWebformatHeight(); long getViews(); int getWebformatWidth(); int getPreviewWidth(); String getComments(); long getDownloads(); String getPageURL(); String getPreviewURL(); String getWebformatURL(); int getImageWidth(); long getUserId(); String getUser(); PixabayImageType getType(); long getId(); String getUserImageURL(); int getImageHeight(); } | @Test public void getComments() throws Exception { assertEquals(pixabayImage.getComments(), "150"); } |
PixabayImage { public long getDownloads() { return downloads; } PixabayImage(int previewHeight, int likes, int favorites, String tags,
int webformatHeight, long views, int webformatWidth, int previewWidth,
int comments, long downloads, String pageURL, String previewURL,
String webformatURL, int imageWidth, long userId, String user,
PixabayImageType type, long id, String userImageURL, int imageHeight); int getPreviewHeight(); String getLikes(); String getFavorites(); String getTags(); int getWebformatHeight(); long getViews(); int getWebformatWidth(); int getPreviewWidth(); String getComments(); long getDownloads(); String getPageURL(); String getPreviewURL(); String getWebformatURL(); int getImageWidth(); long getUserId(); String getUser(); PixabayImageType getType(); long getId(); String getUserImageURL(); int getImageHeight(); } | @Test public void getDownloads() throws Exception { assertEquals(pixabayImage.getDownloads(), 987); } |
ClientSpanNameProvider { public static Function<HttpRequest, String> PREFIXED_REQUEST_METHOD_NAME(final String prefix) { return (request) -> replaceIfNull(prefix, "") + replaceIfNull(request.getRequestLine().getMethod(), "unknown"); } static Function<HttpRequest, String> PREFIXED_REQUEST_METHOD_NAME(final String prefix); static Function<HttpRequest, String> PREFIXED_REQUEST_TARGET_NAME(final String prefix); static Function<HttpRequest, String> PREFIXED_REQUEST_METHOD_TARGET_NAME(
final String prefix); static Function<HttpRequest, String> REQUEST_METHOD_NAME; static Function<HttpRequest, String> REQUEST_TARGET_NAME; static Function<HttpRequest, String> REQUEST_METHOD_TARGET_NAME; } | @Test public void prefixedRequestMethodSpanNameFormatsCorrectly() { Function<HttpRequest, String> spanNameProvider = ClientSpanNameProvider .PREFIXED_REQUEST_METHOD_NAME("ELASTICSEARCH - "); assertEquals("ELASTICSEARCH - GET", spanNameProvider.apply(getRequest)); assertEquals("ELASTICSEARCH - GET", spanNameProvider.apply(getRequestWithID)); assertEquals("ELASTICSEARCH - GET", spanNameProvider.apply(getIndexRequestWithIDAndParameters)); assertEquals("ELASTICSEARCH - GET", spanNameProvider.apply(getRequestWithIDWithSource)); assertEquals("ELASTICSEARCH - POST", spanNameProvider.apply(postRequestCancelTaskID)); }
@Test public void prefixedRequestMethodSpanNameHandlesNull() { Function<HttpRequest, String> spanNameProvider = ClientSpanNameProvider .PREFIXED_REQUEST_METHOD_NAME(null); assertEquals("GET", spanNameProvider.apply(getRequest)); assertEquals("GET", spanNameProvider.apply(getRequestWithID)); assertEquals("GET", spanNameProvider.apply(getIndexRequestWithIDAndParameters)); assertEquals("GET", spanNameProvider.apply(getRequestWithIDWithSource)); assertEquals("POST", spanNameProvider.apply(postRequestCancelTaskID)); } |
ClientSpanNameProvider { public static Function<HttpRequest, String> PREFIXED_REQUEST_TARGET_NAME(final String prefix) { return (request) -> replaceIfNull(prefix, "") + replaceIfNull(standardizeUri(request.getRequestLine().getUri()), "unknown"); } static Function<HttpRequest, String> PREFIXED_REQUEST_METHOD_NAME(final String prefix); static Function<HttpRequest, String> PREFIXED_REQUEST_TARGET_NAME(final String prefix); static Function<HttpRequest, String> PREFIXED_REQUEST_METHOD_TARGET_NAME(
final String prefix); static Function<HttpRequest, String> REQUEST_METHOD_NAME; static Function<HttpRequest, String> REQUEST_TARGET_NAME; static Function<HttpRequest, String> REQUEST_METHOD_TARGET_NAME; } | @Test public void prefixedRequestTargetSpanNameFormatsCorrectly() { Function<HttpRequest, String> spanNameProvider = ClientSpanNameProvider .PREFIXED_REQUEST_TARGET_NAME("ELASTICSEARCH - "); assertEquals("ELASTICSEARCH - /twitter/tweet/", spanNameProvider.apply(getRequest)); assertEquals("ELASTICSEARCH - /twitter/tweet/?", spanNameProvider.apply(getRequestWithID)); assertEquals("ELASTICSEARCH - /twitter/tweet/?", spanNameProvider.apply(getIndexRequestWithIDAndParameters)); assertEquals("ELASTICSEARCH - /twitter/tweet/?/_source", spanNameProvider.apply(getRequestWithIDWithSource)); assertEquals("ELASTICSEARCH - /_tasks/task_id:?/_cancel", spanNameProvider.apply(postRequestCancelTaskID)); }
@Test public void prefixedRequestTargetSpanNameHandlesNull() { Function<HttpRequest, String> spanNameProvider = ClientSpanNameProvider .PREFIXED_REQUEST_TARGET_NAME(null); assertEquals("/twitter/tweet/", spanNameProvider.apply(getRequest)); assertEquals("/twitter/tweet/?", spanNameProvider.apply(getRequestWithID)); assertEquals("/twitter/tweet/?", spanNameProvider.apply(getIndexRequestWithIDAndParameters)); assertEquals("/twitter/tweet/?/_source", spanNameProvider.apply(getRequestWithIDWithSource)); assertEquals("/_tasks/task_id:?/_cancel", spanNameProvider.apply(postRequestCancelTaskID)); } |
ClientSpanNameProvider { public static Function<HttpRequest, String> PREFIXED_REQUEST_METHOD_TARGET_NAME( final String prefix) { return (request) -> replaceIfNull(prefix, "") + replaceIfNull(request.getRequestLine().getMethod(), "unknown") + " " + replaceIfNull(standardizeUri(request.getRequestLine().getUri()), "unknown"); } static Function<HttpRequest, String> PREFIXED_REQUEST_METHOD_NAME(final String prefix); static Function<HttpRequest, String> PREFIXED_REQUEST_TARGET_NAME(final String prefix); static Function<HttpRequest, String> PREFIXED_REQUEST_METHOD_TARGET_NAME(
final String prefix); static Function<HttpRequest, String> REQUEST_METHOD_NAME; static Function<HttpRequest, String> REQUEST_TARGET_NAME; static Function<HttpRequest, String> REQUEST_METHOD_TARGET_NAME; } | @Test public void prefixedRequestMethodTargetSpanNameFormatsCorrectly() { Function<HttpRequest, String> spanNameProvider = ClientSpanNameProvider .PREFIXED_REQUEST_METHOD_TARGET_NAME("ELASTICSEARCH - "); assertEquals("ELASTICSEARCH - GET /twitter/tweet/", spanNameProvider.apply(getRequest)); assertEquals("ELASTICSEARCH - GET /twitter/tweet/?", spanNameProvider.apply(getRequestWithID)); assertEquals("ELASTICSEARCH - GET /twitter/tweet/?", spanNameProvider.apply(getIndexRequestWithIDAndParameters)); assertEquals("ELASTICSEARCH - GET /twitter/tweet/?/_source", spanNameProvider.apply(getRequestWithIDWithSource)); assertEquals("ELASTICSEARCH - POST /_tasks/task_id:?/_cancel", spanNameProvider.apply(postRequestCancelTaskID)); }
@Test public void prefixedRequestMethodTargetSpanNameHandlesNull() { Function<HttpRequest, String> spanNameProvider = ClientSpanNameProvider .PREFIXED_REQUEST_METHOD_TARGET_NAME(null); assertEquals("GET /twitter/tweet/", spanNameProvider.apply(getRequest)); assertEquals("GET /twitter/tweet/?", spanNameProvider.apply(getRequestWithID)); assertEquals("GET /twitter/tweet/?", spanNameProvider.apply(getIndexRequestWithIDAndParameters)); assertEquals("GET /twitter/tweet/?/_source", spanNameProvider.apply(getRequestWithIDWithSource)); assertEquals("POST /_tasks/task_id:?/_cancel", spanNameProvider.apply(postRequestCancelTaskID)); } |
RxReceiver { @NonNull public static Observable<Intent> receives(@NonNull final Context context, @NonNull final IntentFilter intentFilter) { return Observable.create(new ObservableOnSubscribe<Intent>() { @Override public void subscribe(final ObservableEmitter<Intent> emitter) { final BroadcastReceiver receiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { emitter.onNext(intent); } }; context.registerReceiver(receiver, intentFilter); emitter.setCancellable(new Cancellable() { @Override public void cancel() throws Exception { if (Looper.getMainLooper() == Looper.myLooper()) { context.unregisterReceiver(receiver); } else { final Scheduler.Worker inner = mainThread().createWorker(); inner.schedule(new Runnable() { @Override public void run() { context.unregisterReceiver(receiver); inner.dispose(); } }); } } }); } }); } @NonNull static Observable<Intent> receives(@NonNull final Context context, @NonNull final IntentFilter intentFilter); } | @Test public void test() { IntentFilter intentFilter = new IntentFilter("test"); Context context = RuntimeEnvironment.application.getApplicationContext(); TestObserver<Intent> tester = RxReceiver.receives(context, intentFilter) .test(); Intent foobar = new Intent("test").putExtra("foo", "bar"); context.sendBroadcast(foobar); tester.assertValues(foobar); Intent barbaz = new Intent("test").putExtra("bar", "baz"); context.sendBroadcast(barbaz); tester.assertValues(foobar, barbaz); Intent nullIntent = new Intent("test_null").putExtra("bar", "baz"); context.sendBroadcast(nullIntent); tester.assertValues(foobar, barbaz); context.sendBroadcast(barbaz); tester.assertValues(foobar, barbaz, barbaz); } |
RxReceiver { @NonNull @CheckResult public static Observable<Intent> receives(@NonNull final Context context, @NonNull final IntentFilter intentFilter) { return Observable.create(new Action1<Emitter<Intent>>() { @Override public void call(final Emitter<Intent> emitter) { final BroadcastReceiver receiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { emitter.onNext(intent); } }; emitter.setCancellation(new Cancellable() { @Override public void cancel() throws Exception { if (Looper.getMainLooper() == Looper.myLooper()) { context.unregisterReceiver(receiver); } else { final Scheduler.Worker inner = mainThread().createWorker(); inner.schedule(new Action0() { @Override public void call() { context.unregisterReceiver(receiver); inner.unsubscribe(); } }); } } }); context.registerReceiver(receiver, intentFilter); } }, Emitter.BackpressureMode.BUFFER); } @NonNull @CheckResult static Observable<Intent> receives(@NonNull final Context context, @NonNull final IntentFilter intentFilter); } | @Test public void subscribe() { IntentFilter intentFilter = new IntentFilter("test_action"); Application application = RuntimeEnvironment.application; TestSubscriber<Intent> o = new TestSubscriber<>(); Subscription subscription = RxReceiver.receives(application, intentFilter).subscribe(o); o.assertValues(); Intent intent1 = new Intent("test_action").putExtra("foo", "bar"); application.sendBroadcast(intent1); o.assertValues(intent1); Intent intent2 = new Intent("test_action").putExtra("bar", "baz"); application.sendBroadcast(intent2); o.assertValues(intent1, intent2); Intent intent3 = new Intent("test_action_ignored"); application.sendBroadcast(intent3); o.assertValues(intent1, intent2); Intent intent4 = new Intent("test_action").putExtra("bar", "baz"); subscription.unsubscribe(); application.sendBroadcast(intent4); o.assertValues(intent1, intent2); } |
RxReceiverLocal { @NonNull public static Observable<Intent> receives(@NonNull final Context context, @NonNull final IntentFilter intentFilter) { return Observable.create(new ObservableOnSubscribe<Intent>() { @Override public void subscribe(final ObservableEmitter<Intent> emitter) { final BroadcastReceiver receiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { emitter.onNext(intent); } }; LocalBroadcastManager.getInstance(context).registerReceiver(receiver, intentFilter); emitter.setCancellable(new Cancellable() { @Override public void cancel() throws Exception { if (Looper.getMainLooper() == Looper.myLooper()) { LocalBroadcastManager.getInstance(context).unregisterReceiver(receiver); } else { final Scheduler.Worker inner = mainThread().createWorker(); inner.schedule(new Runnable() { @Override public void run() { LocalBroadcastManager.getInstance(context).unregisterReceiver(receiver); inner.dispose(); } }); } } }); } }); } @NonNull static Observable<Intent> receives(@NonNull final Context context, @NonNull final IntentFilter intentFilter); } | @Test public void test() { IntentFilter intentFilter = new IntentFilter("test"); Context context = RuntimeEnvironment.application.getApplicationContext(); TestObserver<Intent> tester = RxReceiverLocal.receives(context, intentFilter) .test(); Intent foobar = new Intent("test").putExtra("foo", "bar"); LocalBroadcastManager.getInstance(context).sendBroadcast(foobar); tester.assertValues(foobar); Intent barbaz = new Intent("test").putExtra("bar", "baz"); LocalBroadcastManager.getInstance(context).sendBroadcast(barbaz); tester.assertValues(foobar, barbaz); Intent nullIntent = new Intent("test_null").putExtra("bar", "baz"); LocalBroadcastManager.getInstance(context).sendBroadcast(nullIntent); tester.assertValues(foobar, barbaz); LocalBroadcastManager.getInstance(context).sendBroadcast(barbaz); tester.assertValues(foobar, barbaz, barbaz); } |
RxReceiverLocal { @NonNull @CheckResult public static Observable<Intent> receives(@NonNull final Context context, @NonNull final IntentFilter intentFilter) { return Observable.create(new Action1<Emitter<Intent>>() { @Override public void call(final Emitter<Intent> emitter) { final BroadcastReceiver receiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { emitter.onNext(intent); } }; emitter.setCancellation(new Cancellable() { @Override public void cancel() throws Exception { if (Looper.getMainLooper() == Looper.myLooper()) { LocalBroadcastManager.getInstance(context).unregisterReceiver(receiver); } else { final Scheduler.Worker inner = mainThread().createWorker(); inner.schedule(new Action0() { @Override public void call() { LocalBroadcastManager.getInstance(context).unregisterReceiver(receiver); inner.unsubscribe(); } }); } } }); LocalBroadcastManager.getInstance(context).registerReceiver(receiver, intentFilter); } }, Emitter.BackpressureMode.BUFFER); } @NonNull @CheckResult static Observable<Intent> receives(@NonNull final Context context, @NonNull final IntentFilter intentFilter); } | @Test public void subscribe() { IntentFilter intentFilter = new IntentFilter("test_action"); Application application = RuntimeEnvironment.application; TestSubscriber<Intent> o = new TestSubscriber<>(); Subscription subscription = RxReceiverLocal.receives(application, intentFilter).subscribe(o); o.assertValues(); Intent intent1 = new Intent("test_action").putExtra("foo", "bar"); LocalBroadcastManager.getInstance(application).sendBroadcast(intent1); o.assertValues(intent1); Intent intent2 = new Intent("test_action").putExtra("bar", "baz"); LocalBroadcastManager.getInstance(application).sendBroadcast(intent2); o.assertValues(intent1, intent2); Intent intent3 = new Intent("test_action_ignored"); LocalBroadcastManager.getInstance(application).sendBroadcast(intent3); o.assertValues(intent1, intent2); Intent intent4 = new Intent("test_action").putExtra("bar", "baz"); subscription.unsubscribe(); LocalBroadcastManager.getInstance(application).sendBroadcast(intent4); o.assertValues(intent1, intent2); } |
FlaxModel { protected void notifyModelChanged() { modelSubject.onNext((M)this); } FlaxModel(); } | @Test public void testNotifyModelChanged() throws Exception { TestObserver testSubscriber = flaxModel.getObservable().test(); flaxModel.notifyModelChanged(); flaxModel.notifyModelChanged(); testSubscriber.assertValueCount(3); testSubscriber.assertValues(flaxModel, flaxModel, flaxModel); } |
FlaxStore { static<M extends FlaxModel> M getModel(Class modelClass) { return getModel(modelClass, 0); } private FlaxStore(); } | @Test public void testStoreReturnsSameValueForSameKeys() throws Exception { Foo fooOne = FlaxStore.getModel(Foo.class, 0); Foo fooTwo = FlaxStore.getModel(Foo.class, 0); assertEquals("fooOne and fooTwo should be the same but they are different.", fooOne, fooTwo); }
@Test public void testStoreReturnsDifferentValuesForDifferentKeys() throws Exception { Foo fooOne = FlaxStore.getModel(Foo.class, 0); Foo fooTwo = FlaxStore.getModel(Foo.class, 1); assertNotEquals("fooOne and fooTwo should be different but they are the same.", fooOne, fooTwo); } |
GrizzlyExecutorService extends AbstractExecutorService implements ExtendedThreadPool { public static GrizzlyExecutorService createInstance() { return createInstance(ThreadPoolConfig.DEFAULT); } protected GrizzlyExecutorService(ThreadPoolConfig config); protected GrizzlyExecutorService(ThreadPoolConfig config, boolean initialize); static GrizzlyExecutorService createInstance(); static GrizzlyExecutorService createInstance(ThreadPoolConfig cfg); GrizzlyExecutorService reconfigure(ThreadPoolConfig config); ThreadPoolConfig getConfiguration(); void shutdown(); List<Runnable> shutdownNow(); boolean isShutdown(); boolean isTerminated(); void execute(Runnable r); boolean awaitTermination(long timeout, TimeUnit unit); @Deprecated Queue<Runnable> getQueue(); @Deprecated int getActiveCount(); @Deprecated int getTaskCount(); @Deprecated long getCompletedTaskCount(); @Deprecated int getCorePoolSize(); @Deprecated void setCorePoolSize(int corePoolSize); @Deprecated int getLargestPoolSize(); @Deprecated int getPoolSize(); @Deprecated int getQueueSize(); @Deprecated long getKeepAliveTime(TimeUnit unit); @Deprecated void setKeepAliveTime(long time, TimeUnit unit); @Deprecated int getMaximumPoolSize(); @Deprecated void setMaximumPoolSize(int maximumPoolSize); @Deprecated int getMaxQueuedTasksCount(); @Deprecated void setMaxQueuedTasksCount(int maxTasksCount); @Deprecated String getName(); @Deprecated void setName(String name); @Deprecated int getPriority(); void setPriority(int priority); @Deprecated ThreadFactory getThreadFactory(); @Deprecated void setThreadFactory(ThreadFactory threadFactory); } | @Test public void testCreateInstance() throws Exception { int threads = 100; ThreadPoolConfig cfg = new ThreadPoolConfig("test", -1, threads, null, -1, 0, null, null, Thread.NORM_PRIORITY, null); GrizzlyExecutorService r = GrizzlyExecutorService.createInstance(cfg); final int tasks = 2000000; doTest(r,tasks); assertTrue(r.getMaximumPoolSize() == threads); assertTrue(r.getActiveCount() == 0); assertTrue(r.getCompletedTaskCount() == 0); assertTrue(r.getMaxQueuedTasksCount() == cfg.getQueueLimit()); int jver = Integer.valueOf(System.getProperty("java.version").substring(0,3).replace(".", "")); assertTrue(jver < 16 || r.getQueue().getClass().getSimpleName().contains("LinkedTransferQueue")); doTest(r.reconfigure(r.getConfiguration().setQueueLimit(tasks)),tasks); assertTrue(r.getMaxQueuedTasksCount() == tasks); int coresize = r.getConfiguration().getMaxPoolSize()+1; doTest( r.reconfigure(r.getConfiguration(). setQueue(new LinkedList<Runnable>()). setCorePoolSize(coresize). setKeepAliveTime(1, TimeUnit.MILLISECONDS). setMaxPoolSize(threads+=50)),tasks); assertTrue(r.getQueue().getClass().getSimpleName().contains("LinkedList")); assertTrue(r.getName() == cfg.getPoolName()); assertTrue(r.getMaxQueuedTasksCount() == tasks); assertTrue(r.getCorePoolSize() == coresize); assertTrue(r.getMaximumPoolSize() == threads); r.shutdownNow(); } |
PCA9685 implements Closeable { public void setPwm(int channel, int on, int off) throws IOException { if (i2cDevice != null && channel >= 0 && channel < 16) { try { i2cDevice.writeRegByte(LED0_ON_L + 4 * channel, (byte) (on & 0xFF)); i2cDevice.writeRegByte(LED0_ON_H + 4 * channel, (byte) (on >> 8)); i2cDevice.writeRegByte(LED0_OFF_L + 4 * channel, (byte) (off & 0xFF)); i2cDevice.writeRegByte(LED0_OFF_H + 4 * channel, (byte) (off >> 8)); } catch (IOException e) { e.printStackTrace(); throw e; } } } PCA9685(byte address, @NonNull PeripheralManager manager); void setPwmFreq(int freqHz); void setPwm(int channel, int on, int off); void setAllPwm(int on, int off); @Override void close(); static final byte PCA9685_ADDRESS; } | @Test public void creation() throws Exception { InOrder inOrder = inOrder(i2cDeviceMock); when(peripheralManagerServiceMock.getI2cBusList()).thenReturn(i2cDevices); when(peripheralManagerServiceMock.openI2cDevice("I2C1",0x40)).thenReturn(i2cDeviceMock); when(i2cDeviceMock.readRegByte(MODE1)).thenReturn((byte)0x0); PCA9685 device = new PCA9685((byte)0x40, peripheralManagerServiceMock); inOrder.verify(i2cDeviceMock).writeRegByte(ALL_LED_ON_L, (byte) (0)); inOrder.verify(i2cDeviceMock).writeRegByte(ALL_LED_ON_H, (byte) (0)); inOrder.verify(i2cDeviceMock).writeRegByte(ALL_LED_OFF_L, (byte) (0)); inOrder.verify(i2cDeviceMock).writeRegByte(ALL_LED_OFF_H, (byte) (0)); inOrder.verify(i2cDeviceMock).writeRegByte(MODE2, (byte) OUTDRV); inOrder.verify(i2cDeviceMock).writeRegByte(MODE1, (byte) ALLCALL); inOrder.verify(i2cDeviceMock).writeRegByte(MODE1, (byte) (0)); inOrder.verify(i2cDeviceMock).writeRegByte(MODE1, (byte)16); inOrder.verify(i2cDeviceMock).writeRegByte(PRESCALE, (byte)121); inOrder.verify(i2cDeviceMock).writeRegByte(MODE1, (byte) 0); inOrder.verify(i2cDeviceMock).writeRegByte(MODE1, (byte) (0x80)); device.setPwm(1,10,0); inOrder.verify(i2cDeviceMock).writeRegByte(LED0_ON_L + 4, (byte) (10 & 0xFF)); inOrder.verify(i2cDeviceMock).writeRegByte(LED0_ON_H + 4, (byte) (10 >> 8)); inOrder.verify(i2cDeviceMock).writeRegByte(LED0_OFF_L + 4, (byte) (0)); inOrder.verify(i2cDeviceMock).writeRegByte(LED0_OFF_H + 4, (byte) (0)); inOrder.verifyNoMoreInteractions(); }
@Test public void setPwm() throws Exception { when(peripheralManagerServiceMock.getI2cBusList()).thenReturn(i2cDevices); when(peripheralManagerServiceMock.openI2cDevice("I2C1",0x40)).thenReturn(i2cDeviceMock); when(i2cDeviceMock.readRegByte(MODE1)).thenReturn((byte)0x0); PCA9685 device = new PCA9685((byte)0x40, peripheralManagerServiceMock); InOrder inOrder = inOrder(i2cDeviceMock); device.setPwm(5,10,20); inOrder.verify(i2cDeviceMock).writeRegByte(LED0_ON_L + 4 * 5, (byte) (10 & 0xff)); inOrder.verify(i2cDeviceMock).writeRegByte(LED0_ON_H + 4 * 5, (byte) (10 >> 8)); inOrder.verify(i2cDeviceMock).writeRegByte(LED0_OFF_L + 4 * 5, (byte) (20 & 0xff)); inOrder.verify(i2cDeviceMock).writeRegByte(LED0_OFF_H + 4 * 5, (byte) (20 >> 8)); device.setPwm(7,1000,2123); inOrder.verify(i2cDeviceMock).writeRegByte(LED0_ON_L + 4 * 7, (byte) (1000 & 0xff)); inOrder.verify(i2cDeviceMock).writeRegByte(LED0_ON_H + 4 * 7, (byte) (1000 >> 8)); inOrder.verify(i2cDeviceMock).writeRegByte(LED0_OFF_L + 4 * 7, (byte) (2123 & 0xff)); inOrder.verify(i2cDeviceMock).writeRegByte(LED0_OFF_H + 4 * 7, (byte) (2123 >> 8)); inOrder.verifyNoMoreInteractions(); } |
PCA9685 implements Closeable { public void setPwmFreq(int freqHz) throws IOException { try { double prescaleval = 25000000.0; prescaleval /= 4096.0; prescaleval /= freqHz; prescaleval -= 1.0; Log.d(TAG, String.format("Setting PWM frequency to %d Hz", freqHz)); Log.d(TAG, String.format("Estimated pre-scale: %.4f", prescaleval)); int prescale = (int) Math.floor(prescaleval + 0.5); Log.d(TAG, String.format("Final pre-scale: %d", prescale)); byte oldmode = i2cDevice.readRegByte(MODE1); byte newmode = (byte) ((oldmode & 0x7F) | 0x10); i2cDevice.writeRegByte(MODE1, newmode); i2cDevice.writeRegByte(PRESCALE, (byte) prescale); i2cDevice.writeRegByte(MODE1, oldmode); Thread.sleep(5); i2cDevice.writeRegByte(MODE1, (byte) (oldmode | 0x80)); } catch (IOException e) { Log.d(TAG, "IO Error " + e.getMessage()); e.printStackTrace(); throw e; } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } PCA9685(byte address, @NonNull PeripheralManager manager); void setPwmFreq(int freqHz); void setPwm(int channel, int on, int off); void setAllPwm(int on, int off); @Override void close(); static final byte PCA9685_ADDRESS; } | @Test public void setPwmFreq() throws Exception { when(peripheralManagerServiceMock.getI2cBusList()).thenReturn(i2cDevices); when(peripheralManagerServiceMock.openI2cDevice("I2C1",0x40)).thenReturn(i2cDeviceMock); when(i2cDeviceMock.readRegByte(MODE1)).thenReturn((byte)0x0); PCA9685 device = new PCA9685((byte)0x40, peripheralManagerServiceMock); InOrder inOrder = inOrder(i2cDeviceMock); device.setPwmFreq(30); inOrder.verify(i2cDeviceMock).writeRegByte(MODE1, (byte)16); inOrder.verify(i2cDeviceMock).writeRegByte(PRESCALE, (byte)202); inOrder.verify(i2cDeviceMock).writeRegByte(MODE1, (byte) 0); inOrder.verify(i2cDeviceMock).writeRegByte(MODE1, (byte) (0x80)); inOrder.verifyNoMoreInteractions(); } |
PCA9685 implements Closeable { public void setAllPwm(int on, int off) throws IOException { if (i2cDevice != null) { try { i2cDevice.writeRegByte(ALL_LED_ON_L, (byte) (on & 0xFF)); i2cDevice.writeRegByte(ALL_LED_ON_H, (byte) (on >> 8)); i2cDevice.writeRegByte(ALL_LED_OFF_L, (byte) (off & 0xFF)); i2cDevice.writeRegByte(ALL_LED_OFF_H, (byte) (off >> 8)); } catch (IOException e) { e.printStackTrace(); throw e; } } } PCA9685(byte address, @NonNull PeripheralManager manager); void setPwmFreq(int freqHz); void setPwm(int channel, int on, int off); void setAllPwm(int on, int off); @Override void close(); static final byte PCA9685_ADDRESS; } | @Test public void setAllPwm() throws Exception { when(peripheralManagerServiceMock.getI2cBusList()).thenReturn(i2cDevices); when(peripheralManagerServiceMock.openI2cDevice("I2C1",0x40)).thenReturn(i2cDeviceMock); when(i2cDeviceMock.readRegByte(MODE1)).thenReturn((byte)0x0); PCA9685 device = new PCA9685((byte)0x40, peripheralManagerServiceMock); InOrder inOrder = inOrder(i2cDeviceMock); device.setAllPwm(10,20); inOrder.verify(i2cDeviceMock).writeRegByte(ALL_LED_ON_L ,(byte) (10 & 0xff)); inOrder.verify(i2cDeviceMock).writeRegByte(ALL_LED_ON_H ,(byte) (10 >> 8)); inOrder.verify(i2cDeviceMock).writeRegByte(ALL_LED_OFF_L, (byte) (20 & 0xff)); inOrder.verify(i2cDeviceMock).writeRegByte(ALL_LED_OFF_H, (byte) (20 >> 8)); device.setAllPwm(1000,2123); inOrder.verify(i2cDeviceMock).writeRegByte(ALL_LED_ON_L ,(byte) (1000 & 0xff)); inOrder.verify(i2cDeviceMock).writeRegByte(ALL_LED_ON_H ,(byte) (1000 >> 8)); inOrder.verify(i2cDeviceMock).writeRegByte(ALL_LED_OFF_L, (byte) (2123 & 0xff)); inOrder.verify(i2cDeviceMock).writeRegByte(ALL_LED_OFF_H, (byte) (2123 >> 8)); inOrder.verifyNoMoreInteractions(); } |
PCA9685Servo extends PCA9685 { public void setServoAngle(int channel, int angle) throws IOException { setPwm(channel, 0, map(angle, minAngle, maxAngle, minPwm, maxPwm)); } PCA9685Servo(byte address, @NonNull PeripheralManager manager); void setServoMinMaxPwm(int minAngle, int maxAngle, int minPwm, int maxPwm); void setServoAngle(int channel, int angle); int map(int x, int inMin, int inMax, int outMin, int outMax); } | @Test public void setServoAngle() throws Exception { when(peripheralManagerServiceMock.getI2cBusList()).thenReturn(i2cDevices); when(peripheralManagerServiceMock.openI2cDevice("I2C1",0x40)).thenReturn(i2cDeviceMock); when(i2cDeviceMock.readRegByte(MODE1)).thenReturn((byte)0x0); PCA9685Servo device = new PCA9685Servo((byte)0x40, peripheralManagerServiceMock); InOrder inOrder = inOrder(i2cDeviceMock); device.setServoMinMaxPwm(0,180,10,210); device.setServoAngle(2,90); inOrder.verify(i2cDeviceMock).writeRegByte(LED0_ON_L + 4 * 2, (byte) (0)); inOrder.verify(i2cDeviceMock).writeRegByte(LED0_ON_H + 4 * 2, (byte) (0)); inOrder.verify(i2cDeviceMock).writeRegByte(LED0_OFF_L + 4 * 2, (byte) (110 & 0xff)); inOrder.verify(i2cDeviceMock).writeRegByte(LED0_OFF_H + 4 * 2, (byte) (110 >> 8)); device.setServoAngle(2,45); inOrder.verify(i2cDeviceMock).writeRegByte(LED0_ON_L + 4 * 2, (byte) (0)); inOrder.verify(i2cDeviceMock).writeRegByte(LED0_ON_H + 4 * 2, (byte) (0)); inOrder.verify(i2cDeviceMock).writeRegByte(LED0_OFF_L + 4 * 2, (byte) (60 & 0xff)); inOrder.verify(i2cDeviceMock).writeRegByte(LED0_OFF_H + 4 * 2, (byte) (60 >> 8)); inOrder.verifyNoMoreInteractions(); } |
PCA9685Servo extends PCA9685 { public int map(int x, int inMin, int inMax, int outMin, int outMax) { return (x - inMin) * (outMax - outMin) / (inMax - inMin) + outMin; } PCA9685Servo(byte address, @NonNull PeripheralManager manager); void setServoMinMaxPwm(int minAngle, int maxAngle, int minPwm, int maxPwm); void setServoAngle(int channel, int angle); int map(int x, int inMin, int inMax, int outMin, int outMax); } | @Test public void map() throws Exception { PCA9685Servo device = new PCA9685Servo((byte)0x40, peripheralManagerServiceMock); assertEquals(20,device.map(0,10,20,30,40)); assertEquals(21,device.map(1,10,20,30,40)); assertEquals(22,device.map(2,10,20,30,40)); assertEquals(23,device.map(3,10,20,30,40)); assertEquals(24,device.map(4,10,20,30,40)); assertEquals(25,device.map(5,10,20,30,40)); assertEquals(26,device.map(6,10,20,30,40)); assertEquals(27,device.map(7,10,20,30,40)); assertEquals(28,device.map(8,10,20,30,40)); assertEquals(29,device.map(9,10,20,30,40)); } |
Order { public double getTotal() { double total = 0; for (Product product : products) { total += product.getPrice(); } return total; } Order(Product ... products); double getTotal(); } | @Test public void should_sum_all_prices() { Order order = new Order(new Product(30), new Product(40.0)); assertEquals(70.0, order.getTotal(), ERROR); } |
PgConfigurationProperties implements ApplicationListener<ApplicationReadyEvent> { public int getPageSizeForIds() { return pageSize * idOnlyFactor; } int getPageSizeForIds(); int getQueueSizeForIds(); int getFetchSizeForIds(); int getFetchSize(); @Override void onApplicationEvent(ApplicationReadyEvent event); } | @Test void testGetPageSizeForIds() { assertEquals(100000, uut.getPageSizeForIds()); } |
GrpcFactStore implements FactStore, SmartInitializingSingleton { @Override public Subscription subscribe(@NonNull SubscriptionRequestTO req, @NonNull FactObserver observer) { SubscriptionImpl<Fact> subscription = SubscriptionImpl.on(observer); StreamObserver<FactStoreProto.MSG_Notification> responseObserver = new ClientStreamObserver( subscription); ClientCall<MSG_SubscriptionRequest, MSG_Notification> call = stub.getChannel() .newCall(RemoteFactStoreGrpc.getSubscribeMethod(), stub.getCallOptions() .withWaitForReady()); try { asyncServerStreamingCall(call, converter.toProto(req), responseObserver); } catch (StatusRuntimeException e) { throw wrapRetryable(e); } return subscription.onClose(() -> cancel(call)); } @SuppressWarnings("OptionalUsedAsFieldOrParameterType") @Autowired @Generated GrpcFactStore(FactCastGrpcChannelFactory channelFactory,
@Value("${grpc.client.factstore.credentials:#{null}}") Optional<String> credentials); @Generated @VisibleForTesting GrpcFactStore(Channel channel,
Optional<String> credentials); private GrpcFactStore(RemoteFactStoreBlockingStub newBlockingStub, RemoteFactStoreStub newStub,
Optional<String> credentials); @Override Optional<Fact> fetchById(UUID id); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override Subscription subscribe(@NonNull SubscriptionRequestTO req,
@NonNull FactObserver observer); @Override OptionalLong serialOf(@NonNull UUID l); synchronized void initialize(); @Override synchronized void afterSingletonsInstantiated(); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(String ns); @Override boolean publishIfUnchanged(@NonNull List<? extends Fact> factsToPublish,
@NonNull Optional<StateToken> token); @Override void invalidate(@NonNull StateToken token); @Override StateToken stateFor(@NonNull Collection<UUID> forAggIds, @NonNull Optional<String> ns); @Override long currentTime(); } | @Test void testSubscribe() throws Exception { assertThrows(NullPointerException.class, () -> uut.subscribe(mock( SubscriptionRequestTO.class), null)); assertThrows(NullPointerException.class, () -> uut.subscribe(null, null)); assertThrows(NullPointerException.class, () -> uut.subscribe(null, mock( FactObserver.class))); }
@Test void testSubscribeNull() { expectNPE(() -> uut.subscribe(null, mock(FactObserver.class))); expectNPE(() -> uut.subscribe(null, null)); expectNPE(() -> uut.subscribe(mock(SubscriptionRequestTO.class), null)); }
@Test void testSubscribeNullParameters() throws Exception { expectNPE(() -> uut.subscribe(null, mock(FactObserver.class))); expectNPE(() -> uut.subscribe(mock(SubscriptionRequestTO.class), null)); expectNPE(() -> uut.subscribe(null, null)); } |
GrpcFactStore implements FactStore, SmartInitializingSingleton { @Override public long currentTime() { MSG_Empty empty = converter.empty(); MSG_CurrentDatabaseTime resp; try { resp = blockingStub.currentTime(empty); } catch (StatusRuntimeException e) { throw wrapRetryable(e); } return converter.fromProto(resp); } @SuppressWarnings("OptionalUsedAsFieldOrParameterType") @Autowired @Generated GrpcFactStore(FactCastGrpcChannelFactory channelFactory,
@Value("${grpc.client.factstore.credentials:#{null}}") Optional<String> credentials); @Generated @VisibleForTesting GrpcFactStore(Channel channel,
Optional<String> credentials); private GrpcFactStore(RemoteFactStoreBlockingStub newBlockingStub, RemoteFactStoreStub newStub,
Optional<String> credentials); @Override Optional<Fact> fetchById(UUID id); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override Subscription subscribe(@NonNull SubscriptionRequestTO req,
@NonNull FactObserver observer); @Override OptionalLong serialOf(@NonNull UUID l); synchronized void initialize(); @Override synchronized void afterSingletonsInstantiated(); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(String ns); @Override boolean publishIfUnchanged(@NonNull List<? extends Fact> factsToPublish,
@NonNull Optional<StateToken> token); @Override void invalidate(@NonNull StateToken token); @Override StateToken stateFor(@NonNull Collection<UUID> forAggIds, @NonNull Optional<String> ns); @Override long currentTime(); } | @Test public void testCurrentTime() throws Exception { long l = 123L; when(blockingStub.currentTime(conv.empty())).thenReturn(conv.toProto(l)); Long t = uut.currentTime(); assertEquals(t, l); } |
GrpcFactStore implements FactStore, SmartInitializingSingleton { @Override public Set<String> enumerateNamespaces() { MSG_Empty empty = converter.empty(); MSG_StringSet resp; try { resp = blockingStub.enumerateNamespaces(empty); } catch (StatusRuntimeException e) { throw wrapRetryable(e); } return converter.fromProto(resp); } @SuppressWarnings("OptionalUsedAsFieldOrParameterType") @Autowired @Generated GrpcFactStore(FactCastGrpcChannelFactory channelFactory,
@Value("${grpc.client.factstore.credentials:#{null}}") Optional<String> credentials); @Generated @VisibleForTesting GrpcFactStore(Channel channel,
Optional<String> credentials); private GrpcFactStore(RemoteFactStoreBlockingStub newBlockingStub, RemoteFactStoreStub newStub,
Optional<String> credentials); @Override Optional<Fact> fetchById(UUID id); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override Subscription subscribe(@NonNull SubscriptionRequestTO req,
@NonNull FactObserver observer); @Override OptionalLong serialOf(@NonNull UUID l); synchronized void initialize(); @Override synchronized void afterSingletonsInstantiated(); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(String ns); @Override boolean publishIfUnchanged(@NonNull List<? extends Fact> factsToPublish,
@NonNull Optional<StateToken> token); @Override void invalidate(@NonNull StateToken token); @Override StateToken stateFor(@NonNull Collection<UUID> forAggIds, @NonNull Optional<String> ns); @Override long currentTime(); } | @Test void testCurrentTimePropagatesRetryableExceptionOnUnavailableStatus() { when(blockingStub.enumerateNamespaces(any())).thenThrow(new StatusRuntimeException( Status.UNAVAILABLE)); assertThrows(RetryableException.class, () -> uut.enumerateNamespaces()); }
@Test void testEnumerateNamespacesPropagatesRetryableExceptionOnUnavailableStatus() { when(blockingStub.enumerateNamespaces(any())).thenThrow(new StatusRuntimeException( Status.UNAVAILABLE)); assertThrows(RetryableException.class, () -> uut.enumerateNamespaces()); }
@Test void testEnumerateNamespaces() { HashSet<String> ns = Sets.newHashSet("foo", "bar"); when(blockingStub.enumerateNamespaces(conv.empty())).thenReturn(conv.toProto(ns)); Set<String> enumerateNamespaces = uut.enumerateNamespaces(); assertEquals(ns, enumerateNamespaces); assertNotSame(ns, enumerateNamespaces); } |
FactCastJson { @SneakyThrows public static <T> T copy(@NonNull T toCopy) { Class<?> c = toCopy.getClass(); return reader.forType(c).readValue(writer.forType(c).writeValueAsString(toCopy)); } @SneakyThrows static T copy(@NonNull T toCopy); @SneakyThrows static String writeValueAsString(@NonNull T value); @SneakyThrows static T readValue(@NonNull Class<T> class1, String json); @SneakyThrows static T readValue(@NonNull Class<T> class1, @NonNull InputStream json); static ObjectNode toObjectNode(String json); static ObjectNode newObjectNode(); @SneakyThrows @Generated static String writeValueAsPrettyString(Object o); } | @Test void testCopyNull() { Assertions.assertThrows(NullPointerException.class, () -> { FactCastJson.copy(null); }); }
@Test void testCopy() { final Foo foo = new Foo("bar", "baz"); Foo copy = FactCastJson.copy(foo); assertNotSame(foo, copy); assertNotEquals(foo, copy); assertEquals(foo.bar(), copy.bar()); assertNull(copy.baz()); } |
FactCastJson { @SneakyThrows public static <T> T readValue(@NonNull Class<T> class1, String json) { return reader.forType(class1).readValue(json); } @SneakyThrows static T copy(@NonNull T toCopy); @SneakyThrows static String writeValueAsString(@NonNull T value); @SneakyThrows static T readValue(@NonNull Class<T> class1, String json); @SneakyThrows static T readValue(@NonNull Class<T> class1, @NonNull InputStream json); static ObjectNode toObjectNode(String json); static ObjectNode newObjectNode(); @SneakyThrows @Generated static String writeValueAsPrettyString(Object o); } | @Test void testReadValueNull() { expectNPE(() -> FactCastJson.readValue(null, "")); expectNPE(() -> FactCastJson.readValue(null, (String) null)); expectNPE(() -> FactCastJson.readValue(FactCastJson.class, (String) null)); expectNPE(() -> FactCastJson.readValue(null, (InputStream) null)); expectNPE(() -> FactCastJson.readValue(FactCastJson.class, (InputStream) null)); }
@Test void testReadValueFromInputStream() { X x = FactCastJson.readValue(X.class, new ByteArrayInputStream("{\"foo\":\"baz\",\"bar\":7}" .getBytes())); assertThat(x.foo).isEqualTo("baz"); assertThat(x.bar).isEqualTo(7); } |
FactCastJson { @SneakyThrows public static <T> String writeValueAsString(@NonNull T value) { return writer.writeValueAsString(value); } @SneakyThrows static T copy(@NonNull T toCopy); @SneakyThrows static String writeValueAsString(@NonNull T value); @SneakyThrows static T readValue(@NonNull Class<T> class1, String json); @SneakyThrows static T readValue(@NonNull Class<T> class1, @NonNull InputStream json); static ObjectNode toObjectNode(String json); static ObjectNode newObjectNode(); @SneakyThrows @Generated static String writeValueAsPrettyString(Object o); } | @Test void testWriteValueNull() { expectNPE(() -> FactCastJson.writeValueAsString(null)); } |
FactCastJson { public static ObjectNode newObjectNode() { return objectMapper.getNodeFactory().objectNode(); } @SneakyThrows static T copy(@NonNull T toCopy); @SneakyThrows static String writeValueAsString(@NonNull T value); @SneakyThrows static T readValue(@NonNull Class<T> class1, String json); @SneakyThrows static T readValue(@NonNull Class<T> class1, @NonNull InputStream json); static ObjectNode toObjectNode(String json); static ObjectNode newObjectNode(); @SneakyThrows @Generated static String writeValueAsPrettyString(Object o); } | @Test void testNewObjectNode() { assertNotNull(FactCastJson.newObjectNode()); assertTrue(FactCastJson.newObjectNode() instanceof ObjectNode); } |
FactCastJson { public static ObjectNode toObjectNode(String json) { try { return (ObjectNode) objectMapper.readTree(json); } catch (IOException e) { throw new RuntimeException(e); } } @SneakyThrows static T copy(@NonNull T toCopy); @SneakyThrows static String writeValueAsString(@NonNull T value); @SneakyThrows static T readValue(@NonNull Class<T> class1, String json); @SneakyThrows static T readValue(@NonNull Class<T> class1, @NonNull InputStream json); static ObjectNode toObjectNode(String json); static ObjectNode newObjectNode(); @SneakyThrows @Generated static String writeValueAsPrettyString(Object o); } | @Test void testToObjectNodeNonJson() { Assertions.assertThrows(RuntimeException.class, () -> { FactCastJson.toObjectNode("no-json"); }); }
@Test void testToObjectNode() { ObjectNode objectNode = FactCastJson.toObjectNode("{\"x\":1}"); JsonNode jsonNode = objectNode.get("x"); assertEquals(1, jsonNode.asInt()); assertNull(objectNode.get("y")); } |
PgFactExtractor implements RowMapper<Fact> { @Override @NonNull public Fact mapRow(@NonNull ResultSet rs, int rowNum) throws SQLException { serial.set(rs.getLong(PgConstants.COLUMN_SER)); return PgFact.from(rs); } @Override @NonNull Fact mapRow(@NonNull ResultSet rs, int rowNum); } | @Test void testMapRowNullContracts() throws Exception { assertThrows(NullPointerException.class, () -> { uut.mapRow(null, 1); }); }
@Test void testMapRow() throws Exception { ResultSet rs = mock(ResultSet.class); final UUID id = UUID.randomUUID(); when(rs.getString(PgConstants.ALIAS_ID)).thenReturn(id.toString()); when(rs.getString(PgConstants.ALIAS_NS)).thenReturn("ns"); when(rs.getString(PgConstants.COLUMN_HEADER)).thenReturn("{\"ns\":\"ns\",\"id\":\"" + id + "\"}"); when(rs.getString(PgConstants.COLUMN_PAYLOAD)).thenReturn("{}"); when(rs.getLong(PgConstants.COLUMN_SER)).thenReturn(27L); Fact mapRow = uut.mapRow(rs, 1); assertEquals(27, serial.get()); assertEquals(id, mapRow.id()); } |
FactCastJson { @SneakyThrows @Generated public static String writeValueAsPrettyString(Object o) { return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(o); } @SneakyThrows static T copy(@NonNull T toCopy); @SneakyThrows static String writeValueAsString(@NonNull T value); @SneakyThrows static T readValue(@NonNull Class<T> class1, String json); @SneakyThrows static T readValue(@NonNull Class<T> class1, @NonNull InputStream json); static ObjectNode toObjectNode(String json); static ObjectNode newObjectNode(); @SneakyThrows @Generated static String writeValueAsPrettyString(Object o); } | @Test void testWriteValueAsPrettyString() { String json = "{\"a\":1}"; String pretty = FactCastJson.writeValueAsPrettyString(FactCastJson.toObjectNode(json)); assertTrue(pretty.contains("\n")); assertTrue(pretty.contains(" ")); }
@Test void testWriteValueAsPrettyFromObject() { @Data class TestObject { String foo = "bar"; } String pretty = FactCastJson.writeValueAsPrettyString(new TestObject()); System.out.println(pretty); assertTrue(pretty.contains("\"foo\" : \"bar\"")); } |
JavaScriptEngineSupplier implements Supplier<ScriptEngine> { @Override public ScriptEngine get() { ScriptEngine engine = getEngineByName("nashorn", "javascript", "js"); if (engine == null) throw new IllegalStateException("Cannot find any engine to run javascript code."); return engine; } JavaScriptEngineSupplier(); @Override ScriptEngine get(); } | @Test void testGet() throws Exception { JavaScriptEngineSupplier uut = spy(new JavaScriptEngineSupplier()); uut.get(); verify(uut).getEngineByName(new String[] { "nashorn", "javascript", "js" }); } |
FactSpec { public static FactSpec ns(String ns) { return new FactSpec(ns); } FactSpec(@NonNull @JsonProperty("ns") String ns); FactSpec meta(@NonNull String k, @NonNull String v); static FactSpec ns(String ns); FilterScript filterScript(); FactSpec filterScript(FilterScript script); @Deprecated FactSpec jsFilterScript(String script); @Deprecated String jsFilterScript(); } | @SuppressWarnings("static-access") @Test void testFactSpecNs() { assertEquals("y", FactSpec.ns("x").ns("y").ns()); }
@Test void testFactSpecType() { assertEquals("y", FactSpec.ns("x").type("y").type()); }
@Test void testFactSpecAggId() { UUID id = UUID.randomUUID(); assertEquals(id, FactSpec.ns("x").aggId(id).aggId()); }
@Test void testFactSpecEquality() { FactSpec f1 = FactSpec.ns("x"); FactSpec f2 = FactSpec.ns("x"); assertEquals(f1, f2); assertNotSame(f1, f2); } |
FactSpec { public FilterScript filterScript() { if (filterScript != null) return filterScript; else if (jsFilterScript != null) return new FilterScript("js", jsFilterScript); else return null; } FactSpec(@NonNull @JsonProperty("ns") String ns); FactSpec meta(@NonNull String k, @NonNull String v); static FactSpec ns(String ns); FilterScript filterScript(); FactSpec filterScript(FilterScript script); @Deprecated FactSpec jsFilterScript(String script); @Deprecated String jsFilterScript(); } | @Test public void testJsFilterScriptDeserDownwardCompatibility() throws Exception { String script = "foo"; String json = "{\"ns\":\"x\",\"jsFilterScript\":\"" + script + "\"}"; FactSpec spec = FactCastJson.readValue(FactSpec.class, json); assertEquals(new FilterScript("js", script), spec.filterScript()); } |
FactSpecMatcher implements Predicate<Fact> { protected boolean metaMatch(Fact t) { if ((meta.isEmpty())) { return true; } return meta.entrySet().stream().allMatch(e -> e.getValue().equals(t.meta(e.getKey()))); } FactSpecMatcher(@NonNull FactSpec spec); @Override boolean test(Fact t); static Predicate<Fact> matchesAnyOf(@NonNull List<FactSpec> spec); static Predicate<Fact> matches(@NonNull FactSpec spec); } | @Test void testMetaMatch() { assertTrue(metaMatch(FactSpec.ns("default").meta("foo", "bar"), new TestFact().meta("foo", "bar"))); assertTrue( metaMatch(FactSpec.ns("default").meta("foo", "bar"), new TestFact().meta("x", "y") .meta("foo", "bar"))); assertTrue(metaMatch(FactSpec.ns("default"), new TestFact().meta("x", "y").meta("foo", "bar"))); assertFalse(metaMatch(FactSpec.ns("default").meta("foo", "bar"), new TestFact().meta("foo", "baz"))); assertFalse(metaMatch(FactSpec.ns("default").meta("foo", "bar"), new TestFact())); } |
PgIdFactExtractor implements RowMapper<Fact> { @Override @NonNull public Fact mapRow(@NonNull ResultSet rs, int rowNum) throws SQLException { serial.set(rs.getLong(PgConstants.COLUMN_SER)); return new IdOnlyFact(UUID.fromString(rs.getString(PgConstants.ALIAS_ID))); } @Override @NonNull Fact mapRow(@NonNull ResultSet rs, int rowNum); } | @Test void testMapRow() throws Exception { ResultSet rs = mock(ResultSet.class); final UUID id = UUID.randomUUID(); when(rs.getString(PgConstants.ALIAS_ID)).thenReturn(id.toString()); when(rs.getLong(PgConstants.COLUMN_SER)).thenReturn(27L); Fact mapRow = uut.mapRow(rs, 1); assertEquals(27, serial.get()); assertEquals(id, mapRow.id()); }
@Test void testMapRowNullContracts() throws Exception { assertThrows(NullPointerException.class, () -> { uut.mapRow(null, 1); }); } |
FactSpecMatcher implements Predicate<Fact> { protected boolean nsMatch(Fact t) { return ns.equals(t.ns()); } FactSpecMatcher(@NonNull FactSpec spec); @Override boolean test(Fact t); static Predicate<Fact> matchesAnyOf(@NonNull List<FactSpec> spec); static Predicate<Fact> matches(@NonNull FactSpec spec); } | @Test void testNsMatch() { assertTrue(nsMatch(FactSpec.ns("default"), new TestFact().ns("default"))); assertFalse(nsMatch(FactSpec.ns("default"), new TestFact().ns("xxx"))); } |
FactSpecMatcher implements Predicate<Fact> { protected boolean typeMatch(Fact t) { if (type == null) { return true; } String otherType = t.type(); return type.equals(otherType); } FactSpecMatcher(@NonNull FactSpec spec); @Override boolean test(Fact t); static Predicate<Fact> matchesAnyOf(@NonNull List<FactSpec> spec); static Predicate<Fact> matches(@NonNull FactSpec spec); } | @Test void testTypeMatch() { assertTrue(typeMatch(FactSpec.ns("default").type("a"), new TestFact().type("a"))); assertTrue(typeMatch(FactSpec.ns("default"), new TestFact().type("a"))); assertFalse(typeMatch(FactSpec.ns("default").type("a"), new TestFact().type("x"))); assertFalse(typeMatch(FactSpec.ns("default").type("a"), new TestFact())); } |
FactSpecMatcher implements Predicate<Fact> { protected boolean aggIdMatch(Fact t) { if (aggId == null) { return true; } return t.aggIds().contains(aggId); } FactSpecMatcher(@NonNull FactSpec spec); @Override boolean test(Fact t); static Predicate<Fact> matchesAnyOf(@NonNull List<FactSpec> spec); static Predicate<Fact> matches(@NonNull FactSpec spec); } | @Test void testAggIdMatch() { UUID u1 = UUID.randomUUID(); UUID u2 = UUID.randomUUID(); assertTrue(aggIdMatch(FactSpec.ns("default").aggId(u1), new TestFact().aggId(u1))); assertTrue(aggIdMatch(FactSpec.ns("default"), new TestFact().aggId(u1))); assertFalse(aggIdMatch(FactSpec.ns("default").aggId(u1), new TestFact().aggId(u2))); assertFalse(aggIdMatch(FactSpec.ns("default").aggId(u1), new TestFact())); } |
FactSpecMatcher implements Predicate<Fact> { @SneakyThrows @Generated protected boolean scriptMatch(Fact t) { if (script == null) { return true; } return (Boolean) scriptEngine.eval("test(" + t.jsonHeader() + "," + t.jsonPayload() + ")"); } FactSpecMatcher(@NonNull FactSpec spec); @Override boolean test(Fact t); static Predicate<Fact> matchesAnyOf(@NonNull List<FactSpec> spec); static Predicate<Fact> matches(@NonNull FactSpec spec); } | @Test void testScriptMatch() { assertTrue(scriptMatch(FactSpec.ns("default"), new TestFact())); assertFalse( scriptMatch(FactSpec.ns("default").jsFilterScript("function (h,e){ return false }"), new TestFact())); assertTrue(scriptMatch(FactSpec.ns("default").jsFilterScript( "function (h,e){ return h.meta.x=='y' }"), new TestFact().meta("x", "y"))); } |
FactSpecMatcher implements Predicate<Fact> { public static Predicate<Fact> matchesAnyOf(@NonNull List<FactSpec> spec) { List<FactSpecMatcher> matchers = spec.stream() .map(FactSpecMatcher::new) .collect(Collectors.toList()); return f -> matchers.stream().anyMatch(p -> p.test(f)); } FactSpecMatcher(@NonNull FactSpec spec); @Override boolean test(Fact t); static Predicate<Fact> matchesAnyOf(@NonNull List<FactSpec> spec); static Predicate<Fact> matches(@NonNull FactSpec spec); } | @Test void testMatchesAnyOfNull() { Assertions.assertThrows(NullPointerException.class, () -> { FactSpecMatcher.matchesAnyOf(null); }); }
@Test void testMatchesAnyOf() { Predicate<Fact> p = FactSpecMatcher.matchesAnyOf(Arrays.asList(FactSpec.ns("1"), FactSpec .ns("2"))); assertTrue(p.test(new TestFact().ns("1"))); assertTrue(p.test(new TestFact().ns("2"))); assertFalse(p.test(new TestFact().ns("3"))); } |
FactSpecMatcher implements Predicate<Fact> { public static Predicate<Fact> matches(@NonNull FactSpec spec) { return new FactSpecMatcher(spec); } FactSpecMatcher(@NonNull FactSpec spec); @Override boolean test(Fact t); static Predicate<Fact> matchesAnyOf(@NonNull List<FactSpec> spec); static Predicate<Fact> matches(@NonNull FactSpec spec); } | @Test public void testMatchesNull() throws Exception { TestHelper.expectNPE(() -> { FactSpecMatcher.matches(null); }); } |
IdOnlyFact implements Fact { @Override public String ns() { throw new UnsupportedOperationException(); } @Override String ns(); @Override String type(); @Override Set<UUID> aggIds(); @Override String jsonHeader(); @Override String jsonPayload(); @Override String meta(String key); } | @Test void testNs() { Assertions.assertThrows(UnsupportedOperationException.class, () -> { new IdOnlyFact(UUID.randomUUID()).ns(); }); } |
IdOnlyFact implements Fact { @Override public String type() { throw new UnsupportedOperationException(); } @Override String ns(); @Override String type(); @Override Set<UUID> aggIds(); @Override String jsonHeader(); @Override String jsonPayload(); @Override String meta(String key); } | @Test void testType() { Assertions.assertThrows(UnsupportedOperationException.class, () -> { new IdOnlyFact(UUID.randomUUID()).type(); }); } |
IdOnlyFact implements Fact { @Override public Set<UUID> aggIds() { throw new UnsupportedOperationException(); } @Override String ns(); @Override String type(); @Override Set<UUID> aggIds(); @Override String jsonHeader(); @Override String jsonPayload(); @Override String meta(String key); } | @Test void testAggIds() { Assertions.assertThrows(UnsupportedOperationException.class, () -> { new IdOnlyFact(UUID.randomUUID()).aggIds(); }); } |
IdOnlyFact implements Fact { @Override public String jsonHeader() { throw new UnsupportedOperationException(); } @Override String ns(); @Override String type(); @Override Set<UUID> aggIds(); @Override String jsonHeader(); @Override String jsonPayload(); @Override String meta(String key); } | @Test void testJsonHeader() { Assertions.assertThrows(UnsupportedOperationException.class, () -> { new IdOnlyFact(UUID.randomUUID()).jsonHeader(); }); } |
IdOnlyFact implements Fact { @Override public String jsonPayload() { throw new UnsupportedOperationException(); } @Override String ns(); @Override String type(); @Override Set<UUID> aggIds(); @Override String jsonHeader(); @Override String jsonPayload(); @Override String meta(String key); } | @Test void testJsonPayload() { Assertions.assertThrows(UnsupportedOperationException.class, () -> { new IdOnlyFact(UUID.randomUUID()).jsonPayload(); }); } |
IdOnlyFact implements Fact { @Override public String meta(String key) { throw new UnsupportedOperationException(); } @Override String ns(); @Override String type(); @Override Set<UUID> aggIds(); @Override String jsonHeader(); @Override String jsonPayload(); @Override String meta(String key); } | @Test void testMeta() { Assertions.assertThrows(UnsupportedOperationException.class, () -> { new IdOnlyFact(UUID.randomUUID()).meta(""); }); } |
DefaultFact implements Fact, Externalizable { public static Fact of(@NonNull String jsonHeader, @NonNull String jsonPayload) { return new DefaultFact(jsonHeader, jsonPayload); } @Deprecated DefaultFact(); @SneakyThrows protected DefaultFact(String jsonHeader, String jsonPayload); DefaultFact(Header header, String payload); @Override String toString(); static Fact of(@NonNull String jsonHeader, @NonNull String jsonPayload); @Override String meta(String key); @Override void writeExternal(ObjectOutput out); @Override void readExternal(ObjectInput in); @Override UUID id(); @Override String ns(); @Override String type(); @Override Set<UUID> aggIds(); } | @Test void testNullHeader() { Assertions.assertThrows(NullPointerException.class, () -> { DefaultFact.of("{}", null); }); }
@Test void testNullPayload() { Assertions.assertThrows(NullPointerException.class, () -> { DefaultFact.of(null, "{}"); }); }
@Test void testNullContracts() { Assertions.assertThrows(NullPointerException.class, () -> { DefaultFact.of(null, null); }); }
@Test void testUnparsableHeader() { Assertions.assertThrows(JsonParseException.class, () -> { DefaultFact.of("not json at all", "{}"); }); }
@Test void testNoId() { Assertions.assertThrows(IllegalArgumentException.class, () -> { DefaultFact.of("{\"ns\":\"default\"}", "{}"); }); }
@Test void testIdNotUUID() { Assertions.assertThrows(IOException.class, () -> { DefaultFact.of("{\"id\":\"buh\",\"ns\":\"default\"}", "{}"); }); }
@Test void testValidFact() { DefaultFact.of("{\"id\":\"" + UUID.randomUUID() + "\",\"ns\":\"default\"}", "{}"); }
@Test void testExternalization() throws Exception { Fact f = DefaultFact.of("{\"id\":\"" + UUID.randomUUID() + "\",\"ns\":\"default\",\"meta\":{\"foo\":7}}", "{}"); Fact copy = copyBySerialization(f); assertEquals(f, copy); }
@Test void testJsonHeader() { final UUID id = UUID.randomUUID(); final UUID aid = UUID.randomUUID(); final String header = "{\"id\":\"" + id + "\",\"ns\":\"narf\",\"type\":\"foo\",\"aggIds\":[\"" + aid + "\"],\"meta\":{\"foo\":7}}"; Fact f = DefaultFact.of(header, "{}"); assertSame(header, f.jsonHeader()); }
@Test void testEqualityBasedOnId() { final UUID id = UUID.randomUUID(); final UUID aid = UUID.randomUUID(); final String header = "{\"id\":\"" + id + "\",\"ns\":\"narf\",\"type\":\"foo\",\"aggIds\":[\"" + aid + "\"],\"meta\":{\"foo\":7}}"; Fact f = DefaultFact.of(header, "{}"); Fact f2 = DefaultFact.of("{\"ns\":\"ns\",\"id\":\"" + id + "\"}", "{}"); Fact f3 = DefaultFact.of("{\"ns\":\"ns\",\"id\":\"" + aid + "\"}", "{}"); assertEquals(f, f); assertEquals(f, f2); assertNotEquals(f, f3); }
@Test void testEqualityMustBeBasedOnIDOnly() { UUID id = UUID.randomUUID(); Fact f1 = DefaultFact.of("{\"id\":\"" + id + "\",\"ns\":\"narf\",\"type\":\"foo\",\"aggIds\":[\"" + UUID.randomUUID() + "\"],\"meta\":{\"foo\":7}}", "{}"); Fact f2 = DefaultFact.of("{\"id\":\"" + id + "\",\"ns\":\"poit\",\"type\":\"bar\",\"aggIds\":[\"" + UUID.randomUUID() + "\"],\"meta\":{\"foo\":7}}", "{}"); assertEquals(f1, f2); }
@Test void testOfNoId() { Assertions.assertThrows(IllegalArgumentException.class, () -> { Fact.of("{\"ns\":\"narf\"}", "{}"); }); }
@Test void testOfNoNs() { Assertions.assertThrows(IllegalArgumentException.class, () -> { Fact.of("{\"id\":\"" + UUID.randomUUID() + "\"}", "{}"); }); }
@Test void testOfEmptyNs() { Assertions.assertThrows(IllegalArgumentException.class, () -> { Fact.of("{\"id\":\"" + UUID.randomUUID() + "\",\"ns\":\"\"}", "{}"); }); } |
PgFact implements Fact { @SneakyThrows @Generated public static Fact from(ResultSet resultSet) { String id = resultSet.getString(PgConstants.ALIAS_ID); String aggId = resultSet.getString(PgConstants.ALIAS_AGGID); String type = resultSet.getString(PgConstants.ALIAS_TYPE); String ns = resultSet.getString(PgConstants.ALIAS_NS); String jsonHeader = resultSet.getString(PgConstants.COLUMN_HEADER); String jsonPayload = resultSet.getString(PgConstants.COLUMN_PAYLOAD); return new PgFact(UUID.fromString(id), ns, type, toUUIDArray(aggId), jsonHeader, jsonPayload); } @Override String meta(String key); @SneakyThrows @Generated static Fact from(ResultSet resultSet); } | @Test void testFrom() throws Exception { ResultSet rs = mock(ResultSet.class); when(rs.next()).thenReturn(true); String ns = "ns"; String type = "type"; String aggId = UUID.randomUUID().toString(); String aggIdArr = "[\"" + aggId + "\"]"; String header = "{\"meta\":{\"foo\":\"1\",\"bar\":\"2\",\"baz\":\"3\"}}"; String payload = "{}"; when(rs.getString(eq(PgConstants.ALIAS_ID))).thenReturn(aggId); when(rs.getString(eq(PgConstants.ALIAS_NS))).thenReturn(ns); when(rs.getString(eq(PgConstants.ALIAS_TYPE))).thenReturn(type); when(rs.getString(eq(PgConstants.ALIAS_AGGID))).thenReturn(aggIdArr); when(rs.getString(eq(PgConstants.COLUMN_HEADER))).thenReturn(header); when(rs.getString(eq(PgConstants.COLUMN_PAYLOAD))).thenReturn(payload); when(rs.next()).thenReturn(true); PgFact uut = (PgFact) PgFact.from(rs); assertEquals(ns, uut.ns()); assertEquals(type, uut.type()); assertEquals(aggId, uut.aggIds().iterator().next().toString()); assertEquals(aggId, uut.id().toString()); assertEquals(header, uut.jsonHeader()); assertEquals(payload, uut.jsonPayload()); assertEquals("1", uut.meta("foo")); assertEquals("2", uut.meta("bar")); assertEquals("3", uut.meta("baz")); } |
DefaultFactCast implements FactCast { @Override @NonNull public Subscription subscribeEphemeral(@NonNull SubscriptionRequest req, @NonNull FactObserver observer) { return store.subscribe(SubscriptionRequestTO.forFacts(req), observer); } @Override @NonNull Subscription subscribeEphemeral(@NonNull SubscriptionRequest req,
@NonNull FactObserver observer); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override @NonNull OptionalLong serialOf(@NonNull UUID id); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(@NonNull String ns); @Override LockedOperationBuilder lock(@NonNull String ns); @Override LockedOperationBuilder lockGlobally(); @Override Subscription subscribe(@NonNull SubscriptionRequest request,
@NonNull FactObserver observer); } | @Test void testSubscribeEphemeral() { when(store.subscribe(csr.capture(), any())).thenReturn(mock(Subscription.class)); final UUID since = UUID.randomUUID(); SubscriptionRequest r = SubscriptionRequest.follow(FactSpec.ns("foo")) .or(FactSpec.ns("some").type("type")) .from(since); uut.subscribeEphemeral(r, f -> { }); verify(store).subscribe(any(), any()); final SubscriptionRequestTO req = csr.getValue(); assertTrue(req.continuous()); assertFalse(req.idOnly()); assertEquals(since, req.startingAfter().get()); assertFalse(req.ephemeral()); }
@Test void testSubscribeFactsNull() { Assertions.assertThrows(NullPointerException.class, () -> { uut.subscribeEphemeral(null, null); }); }
@Test void testSubscribeFacts1stArgNull() { Assertions.assertThrows(NullPointerException.class, () -> { uut.subscribeEphemeral(null, f -> { }); }); }
@Test void testSubscribeFacts2ndArgNull() { Assertions.assertThrows(NullPointerException.class, () -> { uut.subscribeEphemeral(SubscriptionRequest.follow(FactSpec.ns("foo")).fromScratch(), null); }); } |
DefaultFactCast implements FactCast { @Override public void publish(@NonNull List<? extends Fact> factsToPublish) { FactValidation.validate(factsToPublish); store.publish(factsToPublish); } @Override @NonNull Subscription subscribeEphemeral(@NonNull SubscriptionRequest req,
@NonNull FactObserver observer); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override @NonNull OptionalLong serialOf(@NonNull UUID id); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(@NonNull String ns); @Override LockedOperationBuilder lock(@NonNull String ns); @Override LockedOperationBuilder lockGlobally(); @Override Subscription subscribe(@NonNull SubscriptionRequest request,
@NonNull FactObserver observer); } | @Test void testPublish() { doNothing().when(store).publish(cfacts.capture()); final TestFact f = new TestFact(); uut.publish(f); final List<Fact> l = cfacts.getValue(); assertEquals(1, l.size()); assertTrue(l.contains(f)); }
@Test void testNoId() { Assertions.assertThrows(IllegalArgumentException.class, () -> { uut.publish(new TestFact().id(null)); }); }
@Test void testNoNamespace() { Assertions.assertThrows(IllegalArgumentException.class, () -> { uut.publish(new TestFact().ns(null)); }); }
@Test void testPublishOneNull() { Assertions.assertThrows(NullPointerException.class, () -> { uut.publish((Fact) null); }); }
@Test void testPublishWithAggregatedException() { try { uut.publish(new NullFact()); fail(); } catch (FactValidationException e) { assertThat(e.getMessage()).contains("lacks required namespace"); assertThat(e.getMessage()).contains("lacks required id"); } }
@Test void testPublishManyNull() { Assertions.assertThrows(NullPointerException.class, () -> { uut.publish((List<Fact>) null); }); } |
PgFact implements Fact { @VisibleForTesting static Set<UUID> toUUIDArray(String aggIdArrayAsString) { Set<UUID> set = new LinkedHashSet<>(); if (aggIdArrayAsString != null && aggIdArrayAsString.trim().length() > 2) { UUID[] readValue = FactCastJson.readValue(UUID[].class, aggIdArrayAsString); if (readValue != null) { set.addAll(Arrays.asList(readValue)); } } return set; } @Override String meta(String key); @SneakyThrows @Generated static Fact from(ResultSet resultSet); } | @Test void testToUUIDArrayNull() { Set<UUID> res = PgFact.toUUIDArray(null); assertTrue(res.isEmpty()); }
@Test void testToUUIDArrayEmpty() { Set<UUID> res = PgFact.toUUIDArray("[]"); assertTrue(res.isEmpty()); }
@Test void testToUUIDArraySingle() { UUID aggId1 = UUID.randomUUID(); Set<UUID> res = PgFact.toUUIDArray("[\"" + aggId1 + "\"]"); assertEquals(1, res.size()); assertTrue(res.contains(aggId1)); }
@Test void testToUUIDArrayMutli() { UUID aggId1 = UUID.randomUUID(); UUID aggId2 = UUID.randomUUID(); Set<UUID> res = PgFact.toUUIDArray("[\"" + aggId1 + "\",\"" + aggId2 + "\"]"); assertEquals(2, res.size()); assertTrue(res.contains(aggId1)); assertTrue(res.contains(aggId2)); } |
DefaultFactCast implements FactCast { @Override @NonNull public OptionalLong serialOf(@NonNull UUID id) { return store.serialOf(id); } @Override @NonNull Subscription subscribeEphemeral(@NonNull SubscriptionRequest req,
@NonNull FactObserver observer); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override @NonNull OptionalLong serialOf(@NonNull UUID id); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(@NonNull String ns); @Override LockedOperationBuilder lock(@NonNull String ns); @Override LockedOperationBuilder lockGlobally(); @Override Subscription subscribe(@NonNull SubscriptionRequest request,
@NonNull FactObserver observer); } | @Test void testSerialOf() { when(store.serialOf(any(UUID.class))).thenReturn(OptionalLong.empty()); UUID id = UUID.randomUUID(); uut.serialOf(id); verify(store).serialOf(same(id)); }
@Test void testSerialOfNull() { Assertions.assertThrows(NullPointerException.class, () -> { uut.serialOf(null); }); } |
DefaultFactCast implements FactCast { @Override public Set<String> enumerateNamespaces() { return store.enumerateNamespaces(); } @Override @NonNull Subscription subscribeEphemeral(@NonNull SubscriptionRequest req,
@NonNull FactObserver observer); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override @NonNull OptionalLong serialOf(@NonNull UUID id); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(@NonNull String ns); @Override LockedOperationBuilder lock(@NonNull String ns); @Override LockedOperationBuilder lockGlobally(); @Override Subscription subscribe(@NonNull SubscriptionRequest request,
@NonNull FactObserver observer); } | @Test public void testEnumerateNamespaces() throws Exception { Set<String> set = new HashSet<>(); when(store.enumerateNamespaces()).thenReturn(set); assertSame(set, FactCast.from(store).enumerateNamespaces()); } |
DefaultFactCast implements FactCast { @Override public Set<String> enumerateTypes(@NonNull String ns) { return store.enumerateTypes(ns); } @Override @NonNull Subscription subscribeEphemeral(@NonNull SubscriptionRequest req,
@NonNull FactObserver observer); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override @NonNull OptionalLong serialOf(@NonNull UUID id); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(@NonNull String ns); @Override LockedOperationBuilder lock(@NonNull String ns); @Override LockedOperationBuilder lockGlobally(); @Override Subscription subscribe(@NonNull SubscriptionRequest request,
@NonNull FactObserver observer); } | @Test public void testEnumerateTypesNullContract() throws Exception { assertThrows(NullPointerException.class, () -> { FactCast.from(store).enumerateTypes(null); }); }
@Test public void testEnumerateTypes() throws Exception { Set<String> test = new HashSet<>(); LinkedHashSet<String> other = Sets.newLinkedHashSet("foo"); when(store.enumerateTypes("test")).thenReturn(test); assertSame(test, FactCast.from(store).enumerateTypes("test")); } |
DefaultFactCast implements FactCast { @Override public LockedOperationBuilder lock(@NonNull String ns) { if (ns.trim().isEmpty()) throw new IllegalArgumentException("Namespace must not be empty"); return new LockedOperationBuilder(this.store, ns); } @Override @NonNull Subscription subscribeEphemeral(@NonNull SubscriptionRequest req,
@NonNull FactObserver observer); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override @NonNull OptionalLong serialOf(@NonNull UUID id); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(@NonNull String ns); @Override LockedOperationBuilder lock(@NonNull String ns); @Override LockedOperationBuilder lockGlobally(); @Override Subscription subscribe(@NonNull SubscriptionRequest request,
@NonNull FactObserver observer); } | @Test public void testLockNullContract() throws Exception { assertThrows(NullPointerException.class, () -> { uut.lock(null); }); }
@Test public void testLockNamespaceMustNotBeEmpty() throws Exception { assertThrows(IllegalArgumentException.class, () -> { uut.lock(" "); }); } |
DefaultFactCast implements FactCast { @Override public Subscription subscribe(@NonNull SubscriptionRequest request, @NonNull FactObserver observer) { return new ReconnectingFactSubscriptionWrapper(store, SubscriptionRequestTO.forFacts( request), observer); } @Override @NonNull Subscription subscribeEphemeral(@NonNull SubscriptionRequest req,
@NonNull FactObserver observer); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override @NonNull OptionalLong serialOf(@NonNull UUID id); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(@NonNull String ns); @Override LockedOperationBuilder lock(@NonNull String ns); @Override LockedOperationBuilder lockGlobally(); @Override Subscription subscribe(@NonNull SubscriptionRequest request,
@NonNull FactObserver observer); } | @Test public void testSubscribeNullContracts() throws Exception { assertThrows(NullPointerException.class, () -> { uut.subscribe(null, mock(FactObserver.class)); }); assertThrows(NullPointerException.class, () -> { uut.subscribe(null, null); }); assertThrows(NullPointerException.class, () -> { uut.subscribe(mock(SubscriptionRequest.class), null); }); }
@Test public void testSubscribeClosesDelegate() throws Exception { Subscription sub = mock(Subscription.class); when(store.subscribe(any(), any())).thenReturn(sub); Subscription s = uut.subscribe(SubscriptionRequest.follow(new LinkedList<>()).fromScratch(), new FactObserver() { @Override public void onNext(@NonNull Fact element) { } }); s.close(); verify(sub).close(); }
@Test public void testSubscribeReconnectsOnError() throws Exception { Subscription sub1 = mock(Subscription.class); Subscription sub2 = mock(Subscription.class); ArgumentCaptor<FactObserver> observer = ArgumentCaptor.forClass(FactObserver.class); when(store.subscribe(any(), observer.capture())).thenReturn(sub1).thenReturn(sub2); List<Fact> seen = new LinkedList<Fact>(); Subscription s = uut.subscribe(SubscriptionRequest.follow(new LinkedList<>()).fromScratch(), new FactObserver() { @Override public void onNext(@NonNull Fact element) { seen.add(element); } }); FactObserver fo = observer.getValue(); fo.onNext(new TestFact()); fo.onNext(new TestFact()); verify(store).subscribe(any(), any()); fo.onError(new RuntimeException()); Thread.sleep(200); verify(sub1).close(); verify(store, times(2)).subscribe(any(), any()); fo.onNext(new TestFact()); fo.onNext(new TestFact()); s.close(); verify(sub2).close(); assertThat(seen).hasSize(4); } |
StateToken { public StateToken() { this(UUID.randomUUID()); } StateToken(); } | @Test public void testStateToken() throws Exception { assertThat(new StateToken().uuid()).isNotNull(); } |
IntermediatePublishResult { public Optional<Runnable> andThen() { return Optional.ofNullable(andThen); } Optional<Runnable> andThen(); } | @Test public void testNullContracts() throws Exception { assertThrows(NullPointerException.class, () -> { new IntermediatePublishResult(null); }); assertThrows(NullPointerException.class, () -> { new IntermediatePublishResult(new LinkedList<>()).andThen(null); }); }
@Test public void testAndThen() throws Exception { IntermediatePublishResult uut = new IntermediatePublishResult(new LinkedList<>()).andThen( () -> { }); assertThat(uut.andThen()).isPresent(); } |
LockedOperationBuilder { public OnBuilderStep on(@NonNull UUID aggId, UUID... otherAggIds) { LinkedList<UUID> ids = new LinkedList<>(); ids.add(aggId); ids.addAll(Arrays.asList(otherAggIds)); return new OnBuilderStep(ids); } OnBuilderStep on(@NonNull UUID aggId, UUID... otherAggIds); } | @Test public void testOn() { UUID id = UUID.randomUUID(); OnBuilderStep on = uut.on(id); assertThat(on.ids()).hasSize(1).contains(id); UUID id2 = UUID.randomUUID(); on = uut.on(id, id2); assertThat(on.ids()).hasSize(2).contains(id).contains(id2); assertThrows(NullPointerException.class, () -> { uut.on(null); }); }
@Test public void testOptimistic() throws Exception { UUID id = new UUID(1, 2); WithOptimisticLock wol = uut.on(id).optimistic(); assertThat(wol).isNotNull(); assertThat(wol.ns()).isEqualTo("ns"); assertThat(wol.ids().get(0)).isEqualTo(id); assertThat(wol.ids().size()).isEqualTo(1); }
@Test public void testAttemptNullContracts() throws Exception { assertThrows(NullPointerException.class, () -> { uut.on(UUID.randomUUID()).attempt(null); }); }
@Test public void testAttemptAbortsOnNull() throws Exception { assertThrows(AttemptAbortedException.class, () -> { uut.on(UUID.randomUUID()).attempt(() -> null); }); }
@Test public void testAttemptWithoutPublishing() throws Exception { assertThrows(IllegalArgumentException.class, () -> { @NonNull PublishingResult attempt = uut.on(UUID.randomUUID()).attempt(() -> mock(IntermediatePublishResult.class) ); }); } |
ExceptionAfterPublish extends IllegalStateException { public ExceptionAfterPublish(@NonNull List<Fact> publishedFacts, @NonNull Throwable e) { super("An exception has happened in the 'andThen' part of your publishing attempt. " + "This is a programming error, as the runnable in andThen is not supposed to throw an Exception. " + "Note that publish actually worked, and the ids of your the published facts are " + render(publishedFacts), e); this.publishedFacts = publishedFacts; } ExceptionAfterPublish(@NonNull List<Fact> publishedFacts, @NonNull Throwable e); } | @Test public void testExceptionAfterPublish() throws Exception { Throwable e = Mockito.mock(Exception.class); List facts = new LinkedList<>(); ExceptionAfterPublish uut = new ExceptionAfterPublish(facts, e); assertThat(uut.publishedFacts()).isSameAs(facts); assertThat(uut.getCause()).isSameAs(e); } |
WithOptimisticLock { @NonNull public PublishingResult attempt(@NonNull Attempt operation) throws AttemptAbortedException, OptimisticRetriesExceededException, ExceptionAfterPublish { while (++count <= retry) { StateToken token = store.stateFor(ids, Optional.ofNullable(ns)); try { IntermediatePublishResult r = runAndWrapException(operation); List<Fact> factsToPublish = r.factsToPublish(); if (factsToPublish == null || factsToPublish.isEmpty()) { throw new IllegalArgumentException( "Attempt exited without abort, but does not publish any facts."); } if (store.publishIfUnchanged(r.factsToPublish(), Optional.of(token))) { try { r.andThen().ifPresent(Runnable::run); } catch (Throwable e) { throw new ExceptionAfterPublish(factsToPublish, e); } return new PublishingResult(factsToPublish); } else { sleep(); } } finally { store.invalidate(token); } } throw new OptimisticRetriesExceededException(retry); } @NonNull PublishingResult attempt(@NonNull Attempt operation); } | @Test void attemptReturnsNullShouldBeAnAbort() { WithOptimisticLock uut = new WithOptimisticLock(Mockito.mock(FactStore.class), null, Collections.singletonList(UUID.randomUUID())); Assertions.assertThrows(AttemptAbortedException.class, () -> { uut.attempt(() -> null); } ); } |
SubscriptionImpl implements Subscription { @Override public void close() { if (!closed.getAndSet(true)) { SubscriptionCancelledException closedException = new SubscriptionCancelledException( "Client closed the subscription"); catchup.completeExceptionally(closedException); complete.completeExceptionally(closedException); onClose.run(); } } @Override void close(); @Override Subscription awaitCatchup(); Subscription awaitCatchup(long waitTimeInMillis); @Override Subscription awaitComplete(); Subscription awaitComplete(long waitTimeInMillis); @SuppressFBWarnings("NP_NONNULL_PARAM_VIOLATION") void notifyCatchup(); @SuppressFBWarnings("NP_NONNULL_PARAM_VIOLATION") void notifyComplete(); void notifyError(Throwable e); void notifyElement(@NonNull T e); SubscriptionImpl<T> onClose(Runnable e); static SubscriptionImpl<T> on(@NonNull GenericObserver<T> o); } | @Test void testClose() throws Exception { expect(TimeoutException.class, () -> uut.awaitCatchup(10)); expect(TimeoutException.class, () -> uut.awaitComplete(10)); uut.close(); expect(SubscriptionCancelledException.class, () -> uut.awaitCatchup(10)); expect(SubscriptionCancelledException.class, () -> uut.awaitComplete(10)); } |
SubscriptionImpl implements Subscription { @Override public Subscription awaitCatchup() throws SubscriptionCancelledException { try { catchup.get(); } catch (InterruptedException | ExecutionException e) { throw new SubscriptionCancelledException(e); } return this; } @Override void close(); @Override Subscription awaitCatchup(); Subscription awaitCatchup(long waitTimeInMillis); @Override Subscription awaitComplete(); Subscription awaitComplete(long waitTimeInMillis); @SuppressFBWarnings("NP_NONNULL_PARAM_VIOLATION") void notifyCatchup(); @SuppressFBWarnings("NP_NONNULL_PARAM_VIOLATION") void notifyComplete(); void notifyError(Throwable e); void notifyElement(@NonNull T e); SubscriptionImpl<T> onClose(Runnable e); static SubscriptionImpl<T> on(@NonNull GenericObserver<T> o); } | @Test void testAwaitCatchup() { expect(TimeoutException.class, () -> uut.awaitCatchup(10)); expect(TimeoutException.class, () -> uut.awaitComplete(10)); uut.notifyCatchup(); uut.awaitCatchup(); expect(TimeoutException.class, () -> uut.awaitComplete(10)); } |
SubscriptionImpl implements Subscription { @Override public Subscription awaitComplete() throws SubscriptionCancelledException { try { complete.get(); } catch (InterruptedException | ExecutionException e) { throw new SubscriptionCancelledException(e); } return this; } @Override void close(); @Override Subscription awaitCatchup(); Subscription awaitCatchup(long waitTimeInMillis); @Override Subscription awaitComplete(); Subscription awaitComplete(long waitTimeInMillis); @SuppressFBWarnings("NP_NONNULL_PARAM_VIOLATION") void notifyCatchup(); @SuppressFBWarnings("NP_NONNULL_PARAM_VIOLATION") void notifyComplete(); void notifyError(Throwable e); void notifyElement(@NonNull T e); SubscriptionImpl<T> onClose(Runnable e); static SubscriptionImpl<T> on(@NonNull GenericObserver<T> o); } | @Test void testAwaitComplete() { expect(TimeoutException.class, () -> uut.awaitCatchup(10)); expect(TimeoutException.class, () -> uut.awaitComplete(10)); uut.notifyComplete(); uut.awaitCatchup(); uut.awaitComplete(); } |
SubscriptionImpl implements Subscription { public void notifyElement(@NonNull T e) { if (!closed.get()) { observer.onNext(e); } } @Override void close(); @Override Subscription awaitCatchup(); Subscription awaitCatchup(long waitTimeInMillis); @Override Subscription awaitComplete(); Subscription awaitComplete(long waitTimeInMillis); @SuppressFBWarnings("NP_NONNULL_PARAM_VIOLATION") void notifyCatchup(); @SuppressFBWarnings("NP_NONNULL_PARAM_VIOLATION") void notifyComplete(); void notifyError(Throwable e); void notifyElement(@NonNull T e); SubscriptionImpl<T> onClose(Runnable e); static SubscriptionImpl<T> on(@NonNull GenericObserver<T> o); } | @Test void testNotifyElementNull() { Assertions.assertThrows(NullPointerException.class, () -> { uut.notifyElement(null); }); } |
SubscriptionImpl implements Subscription { public void notifyError(Throwable e) { if (!closed.get()) { observer.onError(e); if (!catchup.isDone()) { catchup.completeExceptionally(e); } if (!complete.isDone()) { complete.completeExceptionally(e); } tryClose(); } } @Override void close(); @Override Subscription awaitCatchup(); Subscription awaitCatchup(long waitTimeInMillis); @Override Subscription awaitComplete(); Subscription awaitComplete(long waitTimeInMillis); @SuppressFBWarnings("NP_NONNULL_PARAM_VIOLATION") void notifyCatchup(); @SuppressFBWarnings("NP_NONNULL_PARAM_VIOLATION") void notifyComplete(); void notifyError(Throwable e); void notifyElement(@NonNull T e); SubscriptionImpl<T> onClose(Runnable e); static SubscriptionImpl<T> on(@NonNull GenericObserver<T> o); } | @Test void testNotifyErrorNull() { Assertions.assertThrows(NullPointerException.class, () -> { uut.notifyError(null); }); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.