diff --git a/main/commons/src/main/java/org/cryptomator/common/CachingSupplier.java b/main/commons/src/main/java/org/cryptomator/common/CachingSupplier.java deleted file mode 100644 index 717d63920..000000000 --- a/main/commons/src/main/java/org/cryptomator/common/CachingSupplier.java +++ /dev/null @@ -1,26 +0,0 @@ -package org.cryptomator.common; - -import java.util.function.Supplier; - -public class CachingSupplier implements Supplier { - - public static Supplier from(Supplier delegate) { - return new CachingSupplier<>(delegate); - } - - private Supplier delegate; - - private CachingSupplier(Supplier delegate) { - this.delegate = () -> { - T result = delegate.get(); - CachingSupplier.this.delegate = () -> result; - return result; - }; - } - - @Override - public T get() { - return delegate.get(); - } - -} diff --git a/main/commons/src/main/java/org/cryptomator/common/Holder.java b/main/commons/src/main/java/org/cryptomator/common/Holder.java deleted file mode 100644 index f147ea3e6..000000000 --- a/main/commons/src/main/java/org/cryptomator/common/Holder.java +++ /dev/null @@ -1,34 +0,0 @@ -package org.cryptomator.common; - -import java.util.function.Consumer; -import java.util.function.Supplier; - -public class Holder implements Supplier, Consumer { - - private final V initial; - - private V value; - - public Holder(W initial) { - this.initial = initial; - reset(); - } - - public V get() { - return value; - } - - public void set(V value) { - this.value = value; - } - - public void reset() { - set(initial); - } - - @Override - public void accept(V value) { - set(value); - } - -} diff --git a/main/commons/src/main/java/org/cryptomator/common/StackTrace.java b/main/commons/src/main/java/org/cryptomator/common/StackTrace.java deleted file mode 100644 index 8d7b64c8a..000000000 --- a/main/commons/src/main/java/org/cryptomator/common/StackTrace.java +++ /dev/null @@ -1,56 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2016 Markus Kreusch and others. - * This file is licensed under the terms of the MIT license. - * See the LICENSE.txt file for more info. - * - * Contributors: - * Markus Kreusch - initial implementation - *******************************************************************************/ -package org.cryptomator.common; - -import java.util.stream.Stream; - -/** - * Utility to print stack traces while analyzing issues. - * - * @author Markus Kreusch - */ -public class StackTrace { - - public static void print(String message) { - Thread thread = Thread.currentThread(); - System.err.println(stackTraceFor(message, thread)); - } - - private static String stackTraceFor(String message, Thread thread) { - StringBuilder result = new StringBuilder(); - appendMessageAndThreadName(result, message, thread); - appendStackTrace(thread, result); - return result.toString(); - } - - private static void appendStackTrace(Thread thread, StringBuilder result) { - Stream.of(thread.getStackTrace()) // - .skip(4) // - .forEach(stackTraceElement -> append(stackTraceElement, result)); - } - - private static void appendMessageAndThreadName(StringBuilder result, String message, Thread thread) { - result // - .append('[') // - .append(thread.getName()) // - .append("] ") // - .append(message); - } - - private static void append(StackTraceElement stackTraceElement, StringBuilder result) { - String className = stackTraceElement.getClassName(); - String methodName = stackTraceElement.getMethodName(); - String fileName = stackTraceElement.getFileName(); - int lineNumber = stackTraceElement.getLineNumber(); - result.append('\n') // - .append(className).append(':').append(methodName) // - .append(" (").append(fileName).append(':').append(lineNumber).append(')'); - } - -} diff --git a/main/commons/src/main/java/org/cryptomator/common/WeakValuedCache.java b/main/commons/src/main/java/org/cryptomator/common/WeakValuedCache.java deleted file mode 100644 index 5dfa131bc..000000000 --- a/main/commons/src/main/java/org/cryptomator/common/WeakValuedCache.java +++ /dev/null @@ -1,48 +0,0 @@ -package org.cryptomator.common; - -import java.util.concurrent.ExecutionException; -import java.util.function.BiConsumer; -import java.util.function.Function; - -import com.google.common.cache.CacheBuilder; -import com.google.common.cache.CacheLoader; -import com.google.common.cache.LoadingCache; -import com.google.common.util.concurrent.ExecutionError; -import com.google.common.util.concurrent.UncheckedExecutionException; - -public class WeakValuedCache { - - private final LoadingCache delegate; - - private WeakValuedCache(Function loader) { - delegate = CacheBuilder.newBuilder() // - .weakValues() // - .build(new CacheLoader() { - @Override - public Value load(Key key) { - return loader.apply(key); - } - }); - } - - public static WeakValuedCache usingLoader(Function loader) { - return new WeakValuedCache<>(loader); - } - - public Value get(Key key) { - try { - return delegate.get(key); - } catch (ExecutionException e) { - throw new IllegalStateException("No checked exception can be thrown by loader", e); - } catch (UncheckedExecutionException e) { - throw (RuntimeException) e.getCause(); - } catch (ExecutionError e) { - throw (Error) e.getCause(); - } - } - - public void forEach(BiConsumer function) { - delegate.asMap().forEach(function); - } - -} diff --git a/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingDoubleStream.java b/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingDoubleStream.java deleted file mode 100644 index 60f571b6a..000000000 --- a/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingDoubleStream.java +++ /dev/null @@ -1,178 +0,0 @@ -package org.cryptomator.common.streams; - -import static org.cryptomator.common.streams.AutoClosingStreamFactory.AUTO_CLOSING_STREAM_FACTORY; - -import java.util.DoubleSummaryStatistics; -import java.util.OptionalDouble; -import java.util.function.BiConsumer; -import java.util.function.DoubleBinaryOperator; -import java.util.function.DoubleConsumer; -import java.util.function.DoublePredicate; -import java.util.function.ObjDoubleConsumer; -import java.util.function.Supplier; -import java.util.stream.DoubleStream; - -public class AutoClosingDoubleStream extends DelegatingDoubleStream { - - public static DoubleStream from(DoubleStream delegate) { - return new AutoClosingDoubleStream(delegate); - } - - public AutoClosingDoubleStream(DoubleStream delegate) { - super(delegate, AUTO_CLOSING_STREAM_FACTORY); - } - - @Override - public void forEach(DoubleConsumer action) { - try { - super.forEach(action); - } finally { - close(); - } - } - - @Override - public void forEachOrdered(DoubleConsumer action) { - try { - super.forEachOrdered(action); - } finally { - close(); - } - } - - @Override - public double[] toArray() { - try { - return super.toArray(); - } finally { - close(); - } - } - - @Override - public double reduce(double identity, DoubleBinaryOperator op) { - try { - return super.reduce(identity, op); - } finally { - close(); - } - } - - @Override - public OptionalDouble reduce(DoubleBinaryOperator op) { - try { - return super.reduce(op); - } finally { - close(); - } - } - - @Override - public R collect(Supplier supplier, ObjDoubleConsumer accumulator, BiConsumer combiner) { - try { - return super.collect(supplier, accumulator, combiner); - } finally { - close(); - } - } - - @Override - public double sum() { - try { - return super.sum(); - } finally { - close(); - } - } - - @Override - public OptionalDouble min() { - try { - return super.min(); - } finally { - close(); - } - } - - @Override - public OptionalDouble max() { - try { - return super.max(); - } finally { - close(); - } - } - - @Override - public long count() { - try { - return super.count(); - } finally { - close(); - } - } - - @Override - public OptionalDouble average() { - try { - return super.average(); - } finally { - close(); - } - } - - @Override - public DoubleSummaryStatistics summaryStatistics() { - try { - return super.summaryStatistics(); - } finally { - close(); - } - } - - @Override - public boolean anyMatch(DoublePredicate predicate) { - try { - return super.anyMatch(predicate); - } finally { - close(); - } - } - - @Override - public boolean allMatch(DoublePredicate predicate) { - try { - return super.allMatch(predicate); - } finally { - close(); - } - } - - @Override - public boolean noneMatch(DoublePredicate predicate) { - try { - return super.noneMatch(predicate); - } finally { - close(); - } - } - - @Override - public OptionalDouble findFirst() { - try { - return super.findFirst(); - } finally { - close(); - } - } - - @Override - public OptionalDouble findAny() { - try { - return super.findAny(); - } finally { - close(); - } - } - -} diff --git a/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingIntStream.java b/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingIntStream.java deleted file mode 100644 index dc3251574..000000000 --- a/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingIntStream.java +++ /dev/null @@ -1,179 +0,0 @@ -package org.cryptomator.common.streams; - -import static org.cryptomator.common.streams.AutoClosingStreamFactory.AUTO_CLOSING_STREAM_FACTORY; - -import java.util.IntSummaryStatistics; -import java.util.OptionalDouble; -import java.util.OptionalInt; -import java.util.function.BiConsumer; -import java.util.function.IntBinaryOperator; -import java.util.function.IntConsumer; -import java.util.function.IntPredicate; -import java.util.function.ObjIntConsumer; -import java.util.function.Supplier; -import java.util.stream.IntStream; - -public class AutoClosingIntStream extends DelegatingIntStream { - - public static IntStream from(IntStream delegate) { - return new AutoClosingIntStream(delegate); - } - - public AutoClosingIntStream(IntStream delegate) { - super(delegate, AUTO_CLOSING_STREAM_FACTORY); - } - - @Override - public void forEach(IntConsumer action) { - try { - super.forEach(action); - } finally { - close(); - } - } - - @Override - public void forEachOrdered(IntConsumer action) { - try { - super.forEachOrdered(action); - } finally { - close(); - } - } - - @Override - public int[] toArray() { - try { - return super.toArray(); - } finally { - close(); - } - } - - @Override - public int reduce(int identity, IntBinaryOperator op) { - try { - return super.reduce(identity, op); - } finally { - close(); - } - } - - @Override - public OptionalInt reduce(IntBinaryOperator op) { - try { - return super.reduce(op); - } finally { - close(); - } - } - - @Override - public R collect(Supplier supplier, ObjIntConsumer accumulator, BiConsumer combiner) { - try { - return super.collect(supplier, accumulator, combiner); - } finally { - close(); - } - } - - @Override - public int sum() { - try { - return super.sum(); - } finally { - close(); - } - } - - @Override - public OptionalInt min() { - try { - return super.min(); - } finally { - close(); - } - } - - @Override - public OptionalInt max() { - try { - return super.max(); - } finally { - close(); - } - } - - @Override - public long count() { - try { - return super.count(); - } finally { - close(); - } - } - - @Override - public OptionalDouble average() { - try { - return super.average(); - } finally { - close(); - } - } - - @Override - public IntSummaryStatistics summaryStatistics() { - try { - return super.summaryStatistics(); - } finally { - close(); - } - } - - @Override - public boolean anyMatch(IntPredicate predicate) { - try { - return super.anyMatch(predicate); - } finally { - close(); - } - } - - @Override - public boolean allMatch(IntPredicate predicate) { - try { - return super.allMatch(predicate); - } finally { - close(); - } - } - - @Override - public boolean noneMatch(IntPredicate predicate) { - try { - return super.noneMatch(predicate); - } finally { - close(); - } - } - - @Override - public OptionalInt findFirst() { - try { - return super.findFirst(); - } finally { - close(); - } - } - - @Override - public OptionalInt findAny() { - try { - return super.findAny(); - } finally { - close(); - } - } - -} diff --git a/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingLongStream.java b/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingLongStream.java deleted file mode 100644 index 4bfc032de..000000000 --- a/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingLongStream.java +++ /dev/null @@ -1,179 +0,0 @@ -package org.cryptomator.common.streams; - -import static org.cryptomator.common.streams.AutoClosingStreamFactory.AUTO_CLOSING_STREAM_FACTORY; - -import java.util.LongSummaryStatistics; -import java.util.OptionalDouble; -import java.util.OptionalLong; -import java.util.function.BiConsumer; -import java.util.function.LongBinaryOperator; -import java.util.function.LongConsumer; -import java.util.function.LongPredicate; -import java.util.function.ObjLongConsumer; -import java.util.function.Supplier; -import java.util.stream.LongStream; - -public class AutoClosingLongStream extends DelegatingLongStream { - - public static LongStream from(LongStream delegate) { - return new AutoClosingLongStream(delegate); - } - - public AutoClosingLongStream(LongStream delegate) { - super(delegate, AUTO_CLOSING_STREAM_FACTORY); - } - - @Override - public void forEach(LongConsumer action) { - try { - super.forEach(action); - } finally { - close(); - } - } - - @Override - public void forEachOrdered(LongConsumer action) { - try { - super.forEachOrdered(action); - } finally { - close(); - } - } - - @Override - public long[] toArray() { - try { - return super.toArray(); - } finally { - close(); - } - } - - @Override - public long reduce(long identity, LongBinaryOperator op) { - try { - return super.reduce(identity, op); - } finally { - close(); - } - } - - @Override - public OptionalLong reduce(LongBinaryOperator op) { - try { - return super.reduce(op); - } finally { - close(); - } - } - - @Override - public R collect(Supplier supplier, ObjLongConsumer accumulator, BiConsumer combiner) { - try { - return super.collect(supplier, accumulator, combiner); - } finally { - close(); - } - } - - @Override - public long sum() { - try { - return super.sum(); - } finally { - close(); - } - } - - @Override - public OptionalLong min() { - try { - return super.min(); - } finally { - close(); - } - } - - @Override - public OptionalLong max() { - try { - return super.max(); - } finally { - close(); - } - } - - @Override - public long count() { - try { - return super.count(); - } finally { - close(); - } - } - - @Override - public OptionalDouble average() { - try { - return super.average(); - } finally { - close(); - } - } - - @Override - public LongSummaryStatistics summaryStatistics() { - try { - return super.summaryStatistics(); - } finally { - close(); - } - } - - @Override - public boolean anyMatch(LongPredicate predicate) { - try { - return super.anyMatch(predicate); - } finally { - close(); - } - } - - @Override - public boolean allMatch(LongPredicate predicate) { - try { - return super.allMatch(predicate); - } finally { - close(); - } - } - - @Override - public boolean noneMatch(LongPredicate predicate) { - try { - return super.noneMatch(predicate); - } finally { - close(); - } - } - - @Override - public OptionalLong findFirst() { - try { - return super.findFirst(); - } finally { - close(); - } - } - - @Override - public OptionalLong findAny() { - try { - return super.findAny(); - } finally { - close(); - } - } - -} diff --git a/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingStream.java b/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingStream.java deleted file mode 100644 index 7207bcf02..000000000 --- a/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingStream.java +++ /dev/null @@ -1,173 +0,0 @@ -package org.cryptomator.common.streams; - -import static org.cryptomator.common.streams.AutoClosingStreamFactory.AUTO_CLOSING_STREAM_FACTORY; - -import java.util.Comparator; -import java.util.Optional; -import java.util.function.BiConsumer; -import java.util.function.BiFunction; -import java.util.function.BinaryOperator; -import java.util.function.Consumer; -import java.util.function.IntFunction; -import java.util.function.Predicate; -import java.util.function.Supplier; -import java.util.stream.Collector; -import java.util.stream.Stream; - -/** - *

- * A Stream which is automatically closed after execution of a terminal operation. - *

- * Streams returned by intermediate operations are also auto closing. - *

- * Note: When using {@link #iterator()} or {@link #spliterator()} auto closing does not occur. - * - * @author Markus Kreusch - */ -public class AutoClosingStream extends DelegatingStream { - - public static Stream from(Stream delegate) { - return new AutoClosingStream<>(delegate); - } - - private AutoClosingStream(Stream delegate) { - super(delegate, AUTO_CLOSING_STREAM_FACTORY); - } - - public void forEach(Consumer action) { - try { - super.forEach(action); - } finally { - close(); - } - } - - public void forEachOrdered(Consumer action) { - try { - super.forEachOrdered(action); - } finally { - close(); - } - } - - public Object[] toArray() { - try { - return super.toArray(); - } finally { - close(); - } - } - - public A[] toArray(IntFunction generator) { - try { - return super.toArray(generator); - } finally { - close(); - } - } - - public T reduce(T identity, BinaryOperator accumulator) { - try { - return super.reduce(identity, accumulator); - } finally { - close(); - } - } - - public Optional reduce(BinaryOperator accumulator) { - try { - return super.reduce(accumulator); - } finally { - close(); - } - } - - public U reduce(U identity, BiFunction accumulator, BinaryOperator combiner) { - try { - return super.reduce(identity, accumulator, combiner); - } finally { - close(); - } - } - - public R collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner) { - try { - return super.collect(supplier, accumulator, combiner); - } finally { - close(); - } - } - - public R collect(Collector collector) { - try { - return super.collect(collector); - } finally { - close(); - } - } - - public Optional min(Comparator comparator) { - try { - return super.min(comparator); - } finally { - close(); - } - } - - public Optional max(Comparator comparator) { - try { - return super.max(comparator); - } finally { - close(); - } - } - - public long count() { - try { - return super.count(); - } finally { - close(); - } - } - - public boolean anyMatch(Predicate predicate) { - try { - return super.anyMatch(predicate); - } finally { - close(); - } - } - - public boolean allMatch(Predicate predicate) { - try { - return super.allMatch(predicate); - } finally { - close(); - } - } - - public boolean noneMatch(Predicate predicate) { - try { - return super.noneMatch(predicate); - } finally { - close(); - } - } - - public Optional findFirst() { - try { - return super.findFirst(); - } finally { - close(); - } - } - - public Optional findAny() { - try { - return super.findAny(); - } finally { - close(); - } - } - -} diff --git a/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingStreamFactory.java b/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingStreamFactory.java deleted file mode 100644 index 18b8ab4d8..000000000 --- a/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingStreamFactory.java +++ /dev/null @@ -1,51 +0,0 @@ -package org.cryptomator.common.streams; - -import java.util.stream.DoubleStream; -import java.util.stream.IntStream; -import java.util.stream.LongStream; -import java.util.stream.Stream; - -class AutoClosingStreamFactory implements DelegatingStreamFactory { - - public static final DelegatingStreamFactory AUTO_CLOSING_STREAM_FACTORY = new AutoClosingStreamFactory(); - - private AutoClosingStreamFactory() { - } - - @Override - public Stream from(Stream other) { - if (AutoClosingStream.class.isInstance(other)) { - return other; - } else { - return AutoClosingStream.from(other); - } - } - - @Override - public IntStream from(IntStream other) { - if (AutoClosingIntStream.class.isInstance(other)) { - return other; - } else { - return AutoClosingIntStream.from(other); - } - } - - @Override - public LongStream from(LongStream other) { - if (AutoClosingLongStream.class.isInstance(other)) { - return other; - } else { - return AutoClosingLongStream.from(other); - } - } - - @Override - public DoubleStream from(DoubleStream other) { - if (AutoClosingDoubleStream.class.isInstance(other)) { - return other; - } else { - return AutoClosingDoubleStream.from(other); - } - } - -} diff --git a/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingDoubleStream.java b/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingDoubleStream.java deleted file mode 100644 index 8fca0e7fd..000000000 --- a/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingDoubleStream.java +++ /dev/null @@ -1,179 +0,0 @@ -package org.cryptomator.common.streams; - -import java.util.DoubleSummaryStatistics; -import java.util.OptionalDouble; -import java.util.PrimitiveIterator.OfDouble; -import java.util.function.BiConsumer; -import java.util.function.DoubleBinaryOperator; -import java.util.function.DoubleConsumer; -import java.util.function.DoubleFunction; -import java.util.function.DoublePredicate; -import java.util.function.DoubleToIntFunction; -import java.util.function.DoubleToLongFunction; -import java.util.function.DoubleUnaryOperator; -import java.util.function.ObjDoubleConsumer; -import java.util.function.Supplier; -import java.util.stream.DoubleStream; -import java.util.stream.IntStream; -import java.util.stream.LongStream; -import java.util.stream.Stream; - -abstract class DelegatingDoubleStream implements DoubleStream { - - private final DoubleStream delegate; - private final DelegatingStreamFactory wrapper; - - public DelegatingDoubleStream(DoubleStream delegate, DelegatingStreamFactory wrapper) { - this.delegate = delegate; - this.wrapper = wrapper; - } - - public DoubleStream filter(DoublePredicate predicate) { - return wrapper.from(delegate.filter(predicate)); - } - - public boolean isParallel() { - return delegate.isParallel(); - } - - public DoubleStream map(DoubleUnaryOperator mapper) { - return wrapper.from(delegate.map(mapper)); - } - - public Stream mapToObj(DoubleFunction mapper) { - return wrapper.from(delegate.mapToObj(mapper)); - } - - public DoubleStream unordered() { - return wrapper.from(delegate.unordered()); - } - - public DoubleStream onClose(Runnable closeHandler) { - return wrapper.from(delegate.onClose(closeHandler)); - } - - public IntStream mapToInt(DoubleToIntFunction mapper) { - return wrapper.from(delegate.mapToInt(mapper)); - } - - public LongStream mapToLong(DoubleToLongFunction mapper) { - return wrapper.from(delegate.mapToLong(mapper)); - } - - public void close() { - delegate.close(); - } - - public DoubleStream flatMap(DoubleFunction mapper) { - return wrapper.from(delegate.flatMap(mapper)); - } - - public DoubleStream distinct() { - return wrapper.from(delegate.distinct()); - } - - public DoubleStream sorted() { - return wrapper.from(delegate.sorted()); - } - - public DoubleStream peek(DoubleConsumer action) { - return wrapper.from(delegate.peek(action)); - } - - public DoubleStream limit(long maxSize) { - return wrapper.from(delegate.limit(maxSize)); - } - - public DoubleStream skip(long n) { - return wrapper.from(delegate.skip(n)); - } - - public void forEach(DoubleConsumer action) { - delegate.forEach(action); - } - - public void forEachOrdered(DoubleConsumer action) { - delegate.forEachOrdered(action); - } - - public double[] toArray() { - return delegate.toArray(); - } - - public double reduce(double identity, DoubleBinaryOperator op) { - return delegate.reduce(identity, op); - } - - public OptionalDouble reduce(DoubleBinaryOperator op) { - return delegate.reduce(op); - } - - public R collect(Supplier supplier, ObjDoubleConsumer accumulator, BiConsumer combiner) { - return delegate.collect(supplier, accumulator, combiner); - } - - public double sum() { - return delegate.sum(); - } - - public OptionalDouble min() { - return delegate.min(); - } - - public OptionalDouble max() { - return delegate.max(); - } - - public long count() { - return delegate.count(); - } - - public OptionalDouble average() { - return delegate.average(); - } - - public DoubleSummaryStatistics summaryStatistics() { - return delegate.summaryStatistics(); - } - - public boolean anyMatch(DoublePredicate predicate) { - return delegate.anyMatch(predicate); - } - - public boolean allMatch(DoublePredicate predicate) { - return delegate.allMatch(predicate); - } - - public boolean noneMatch(DoublePredicate predicate) { - return delegate.noneMatch(predicate); - } - - public OptionalDouble findFirst() { - return delegate.findFirst(); - } - - public OptionalDouble findAny() { - return delegate.findAny(); - } - - public Stream boxed() { - return wrapper.from(delegate.boxed()); - } - - public DoubleStream sequential() { - return wrapper.from(delegate.sequential()); - } - - public DoubleStream parallel() { - return wrapper.from(delegate.parallel()); - } - - public OfDouble iterator() { - return delegate.iterator(); - } - - public java.util.Spliterator.OfDouble spliterator() { - return delegate.spliterator(); - } - -} diff --git a/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingIntStream.java b/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingIntStream.java deleted file mode 100644 index f3ee72e16..000000000 --- a/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingIntStream.java +++ /dev/null @@ -1,188 +0,0 @@ -package org.cryptomator.common.streams; - -import java.util.IntSummaryStatistics; -import java.util.OptionalDouble; -import java.util.OptionalInt; -import java.util.PrimitiveIterator.OfInt; -import java.util.function.BiConsumer; -import java.util.function.IntBinaryOperator; -import java.util.function.IntConsumer; -import java.util.function.IntFunction; -import java.util.function.IntPredicate; -import java.util.function.IntToDoubleFunction; -import java.util.function.IntToLongFunction; -import java.util.function.IntUnaryOperator; -import java.util.function.ObjIntConsumer; -import java.util.function.Supplier; -import java.util.stream.DoubleStream; -import java.util.stream.IntStream; -import java.util.stream.LongStream; -import java.util.stream.Stream; - -abstract class DelegatingIntStream implements IntStream { - - private final IntStream delegate; - private final DelegatingStreamFactory wrapper; - - public DelegatingIntStream(IntStream delegate, DelegatingStreamFactory wrapper) { - this.delegate = delegate; - this.wrapper = wrapper; - } - - public IntStream filter(IntPredicate predicate) { - return wrapper.from(delegate.filter(predicate)); - } - - public boolean isParallel() { - return delegate.isParallel(); - } - - public IntStream map(IntUnaryOperator mapper) { - return wrapper.from(delegate.map(mapper)); - } - - public Stream mapToObj(IntFunction mapper) { - return wrapper.from(delegate.mapToObj(mapper)); - } - - public IntStream unordered() { - return wrapper.from(delegate.unordered()); - } - - public LongStream mapToLong(IntToLongFunction mapper) { - return wrapper.from(delegate.mapToLong(mapper)); - } - - public IntStream onClose(Runnable closeHandler) { - return wrapper.from(delegate.onClose(closeHandler)); - } - - public DoubleStream mapToDouble(IntToDoubleFunction mapper) { - return wrapper.from(delegate.mapToDouble(mapper)); - } - - public void close() { - delegate.close(); - } - - public IntStream flatMap(IntFunction mapper) { - return wrapper.from(delegate.flatMap(mapper)); - } - - public IntStream distinct() { - return wrapper.from(delegate.distinct()); - } - - public IntStream sorted() { - return wrapper.from(delegate.sorted()); - } - - public IntStream peek(IntConsumer action) { - return wrapper.from(delegate.peek(action)); - } - - public IntStream limit(long maxSize) { - return wrapper.from(delegate.limit(maxSize)); - } - - public IntStream skip(long n) { - return wrapper.from(delegate.skip(n)); - } - - public void forEach(IntConsumer action) { - delegate.forEach(action); - } - - public void forEachOrdered(IntConsumer action) { - delegate.forEachOrdered(action); - } - - public int[] toArray() { - return delegate.toArray(); - } - - public int reduce(int identity, IntBinaryOperator op) { - return delegate.reduce(identity, op); - } - - public OptionalInt reduce(IntBinaryOperator op) { - return delegate.reduce(op); - } - - public R collect(Supplier supplier, ObjIntConsumer accumulator, BiConsumer combiner) { - return delegate.collect(supplier, accumulator, combiner); - } - - public int sum() { - return delegate.sum(); - } - - public OptionalInt min() { - return delegate.min(); - } - - public OptionalInt max() { - return delegate.max(); - } - - public long count() { - return delegate.count(); - } - - public OptionalDouble average() { - return delegate.average(); - } - - public IntSummaryStatistics summaryStatistics() { - return delegate.summaryStatistics(); - } - - public boolean anyMatch(IntPredicate predicate) { - return delegate.anyMatch(predicate); - } - - public boolean allMatch(IntPredicate predicate) { - return delegate.allMatch(predicate); - } - - public boolean noneMatch(IntPredicate predicate) { - return delegate.noneMatch(predicate); - } - - public OptionalInt findFirst() { - return delegate.findFirst(); - } - - public OptionalInt findAny() { - return delegate.findAny(); - } - - public LongStream asLongStream() { - return wrapper.from(delegate.asLongStream()); - } - - public DoubleStream asDoubleStream() { - return wrapper.from(delegate.asDoubleStream()); - } - - public Stream boxed() { - return wrapper.from(delegate.boxed()); - } - - public IntStream sequential() { - return wrapper.from(delegate.sequential()); - } - - public IntStream parallel() { - return wrapper.from(delegate.parallel()); - } - - public OfInt iterator() { - return delegate.iterator(); - } - - public java.util.Spliterator.OfInt spliterator() { - return delegate.spliterator(); - } - -} diff --git a/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingLongStream.java b/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingLongStream.java deleted file mode 100644 index c33baef4f..000000000 --- a/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingLongStream.java +++ /dev/null @@ -1,184 +0,0 @@ -package org.cryptomator.common.streams; - -import java.util.LongSummaryStatistics; -import java.util.OptionalDouble; -import java.util.OptionalLong; -import java.util.PrimitiveIterator.OfLong; -import java.util.function.BiConsumer; -import java.util.function.LongBinaryOperator; -import java.util.function.LongConsumer; -import java.util.function.LongFunction; -import java.util.function.LongPredicate; -import java.util.function.LongToDoubleFunction; -import java.util.function.LongToIntFunction; -import java.util.function.LongUnaryOperator; -import java.util.function.ObjLongConsumer; -import java.util.function.Supplier; -import java.util.stream.DoubleStream; -import java.util.stream.IntStream; -import java.util.stream.LongStream; -import java.util.stream.Stream; - -abstract class DelegatingLongStream implements LongStream { - - private final LongStream delegate; - private final DelegatingStreamFactory wrapper; - - public DelegatingLongStream(LongStream delegate, DelegatingStreamFactory wrapper) { - this.delegate = delegate; - this.wrapper = wrapper; - } - - public LongStream filter(LongPredicate predicate) { - return wrapper.from(delegate.filter(predicate)); - } - - public boolean isParallel() { - return delegate.isParallel(); - } - - public LongStream map(LongUnaryOperator mapper) { - return wrapper.from(delegate.map(mapper)); - } - - public Stream mapToObj(LongFunction mapper) { - return wrapper.from(delegate.mapToObj(mapper)); - } - - public LongStream unordered() { - return wrapper.from(delegate.unordered()); - } - - public LongStream onClose(Runnable closeHandler) { - return wrapper.from(delegate.onClose(closeHandler)); - } - - public IntStream mapToInt(LongToIntFunction mapper) { - return wrapper.from(delegate.mapToInt(mapper)); - } - - public DoubleStream mapToDouble(LongToDoubleFunction mapper) { - return wrapper.from(delegate.mapToDouble(mapper)); - } - - public void close() { - delegate.close(); - } - - public LongStream flatMap(LongFunction mapper) { - return wrapper.from(delegate.flatMap(mapper)); - } - - public LongStream distinct() { - return wrapper.from(delegate.distinct()); - } - - public LongStream sorted() { - return wrapper.from(delegate.sorted()); - } - - public LongStream peek(LongConsumer action) { - return wrapper.from(delegate.peek(action)); - } - - public LongStream limit(long maxSize) { - return wrapper.from(delegate.limit(maxSize)); - } - - public LongStream skip(long n) { - return wrapper.from(delegate.skip(n)); - } - - public void forEach(LongConsumer action) { - delegate.forEach(action); - } - - public void forEachOrdered(LongConsumer action) { - delegate.forEachOrdered(action); - } - - public long[] toArray() { - return delegate.toArray(); - } - - public long reduce(long identity, LongBinaryOperator op) { - return delegate.reduce(identity, op); - } - - public OptionalLong reduce(LongBinaryOperator op) { - return delegate.reduce(op); - } - - public R collect(Supplier supplier, ObjLongConsumer accumulator, BiConsumer combiner) { - return delegate.collect(supplier, accumulator, combiner); - } - - public long sum() { - return delegate.sum(); - } - - public OptionalLong min() { - return delegate.min(); - } - - public OptionalLong max() { - return delegate.max(); - } - - public long count() { - return delegate.count(); - } - - public OptionalDouble average() { - return delegate.average(); - } - - public LongSummaryStatistics summaryStatistics() { - return delegate.summaryStatistics(); - } - - public boolean anyMatch(LongPredicate predicate) { - return delegate.anyMatch(predicate); - } - - public boolean allMatch(LongPredicate predicate) { - return delegate.allMatch(predicate); - } - - public boolean noneMatch(LongPredicate predicate) { - return delegate.noneMatch(predicate); - } - - public OptionalLong findFirst() { - return delegate.findFirst(); - } - - public OptionalLong findAny() { - return delegate.findAny(); - } - - public DoubleStream asDoubleStream() { - return wrapper.from(delegate.asDoubleStream()); - } - - public Stream boxed() { - return wrapper.from(delegate.boxed()); - } - - public LongStream sequential() { - return wrapper.from(delegate.sequential()); - } - - public LongStream parallel() { - return wrapper.from(delegate.parallel()); - } - - public OfLong iterator() { - return delegate.iterator(); - } - - public java.util.Spliterator.OfLong spliterator() { - return delegate.spliterator(); - } - -} diff --git a/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingStream.java b/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingStream.java deleted file mode 100644 index 585bb8cd3..000000000 --- a/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingStream.java +++ /dev/null @@ -1,194 +0,0 @@ -package org.cryptomator.common.streams; - -import java.util.Comparator; -import java.util.Iterator; -import java.util.Optional; -import java.util.Spliterator; -import java.util.function.BiConsumer; -import java.util.function.BiFunction; -import java.util.function.BinaryOperator; -import java.util.function.Consumer; -import java.util.function.Function; -import java.util.function.IntFunction; -import java.util.function.Predicate; -import java.util.function.Supplier; -import java.util.function.ToDoubleFunction; -import java.util.function.ToIntFunction; -import java.util.function.ToLongFunction; -import java.util.stream.Collector; -import java.util.stream.DoubleStream; -import java.util.stream.IntStream; -import java.util.stream.LongStream; -import java.util.stream.Stream; - -abstract class DelegatingStream implements Stream { - - private final Stream delegate; - private final DelegatingStreamFactory wrapper; - - protected DelegatingStream(Stream delegate, DelegatingStreamFactory wrapper) { - this.delegate = delegate; - this.wrapper = wrapper; - } - - public Iterator iterator() { - return delegate.iterator(); - } - - public Spliterator spliterator() { - return delegate.spliterator(); - } - - public boolean isParallel() { - return delegate.isParallel(); - } - - public Stream sequential() { - return wrapper.from(delegate.sequential()); - } - - public Stream parallel() { - return wrapper.from(delegate.parallel()); - } - - public Stream unordered() { - return wrapper.from(delegate.unordered()); - } - - public Stream onClose(Runnable closeHandler) { - return wrapper.from(delegate.onClose(closeHandler)); - } - - public void close() { - delegate.close(); - } - - public Stream filter(Predicate predicate) { - return wrapper.from(delegate.filter(predicate)); - } - - public Stream map(Function mapper) { - return wrapper.from(delegate.map(mapper)); - } - - public IntStream mapToInt(ToIntFunction mapper) { - return wrapper.from(delegate.mapToInt(mapper)); - } - - public LongStream mapToLong(ToLongFunction mapper) { - return wrapper.from(delegate.mapToLong(mapper)); - } - - public DoubleStream mapToDouble(ToDoubleFunction mapper) { - return wrapper.from(delegate.mapToDouble(mapper)); - } - - public Stream flatMap(Function> mapper) { - return wrapper.from(delegate.flatMap(mapper)); - } - - public IntStream flatMapToInt(Function mapper) { - return wrapper.from(delegate.flatMapToInt(mapper)); - } - - public LongStream flatMapToLong(Function mapper) { - return wrapper.from(delegate.flatMapToLong(mapper)); - } - - public DoubleStream flatMapToDouble(Function mapper) { - return wrapper.from(delegate.flatMapToDouble(mapper)); - } - - public Stream distinct() { - return wrapper.from(delegate.distinct()); - } - - public Stream sorted() { - return wrapper.from(delegate.sorted()); - } - - public Stream sorted(Comparator comparator) { - return wrapper.from(delegate.sorted(comparator)); - } - - public Stream peek(Consumer action) { - return wrapper.from(delegate.peek(action)); - } - - public Stream limit(long maxSize) { - return wrapper.from(delegate.limit(maxSize)); - } - - public Stream skip(long n) { - return wrapper.from(delegate.skip(n)); - } - - public void forEach(Consumer action) { - delegate.forEach(action); - } - - public void forEachOrdered(Consumer action) { - delegate.forEachOrdered(action); - } - - public Object[] toArray() { - return delegate.toArray(); - } - - public A[] toArray(IntFunction generator) { - return delegate.toArray(generator); - } - - public T reduce(T identity, BinaryOperator accumulator) { - return delegate.reduce(identity, accumulator); - } - - public Optional reduce(BinaryOperator accumulator) { - return delegate.reduce(accumulator); - } - - public U reduce(U identity, BiFunction accumulator, BinaryOperator combiner) { - return delegate.reduce(identity, accumulator, combiner); - } - - public R collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner) { - return delegate.collect(supplier, accumulator, combiner); - } - - public R collect(Collector collector) { - return delegate.collect(collector); - } - - public Optional min(Comparator comparator) { - return delegate.min(comparator); - } - - public Optional max(Comparator comparator) { - return delegate.max(comparator); - } - - public long count() { - return delegate.count(); - } - - public boolean anyMatch(Predicate predicate) { - return delegate.anyMatch(predicate); - } - - public boolean allMatch(Predicate predicate) { - return delegate.allMatch(predicate); - } - - public boolean noneMatch(Predicate predicate) { - return delegate.noneMatch(predicate); - } - - public Optional findFirst() { - return delegate.findFirst(); - } - - public Optional findAny() { - return delegate.findAny(); - } - -} diff --git a/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingStreamFactory.java b/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingStreamFactory.java deleted file mode 100644 index 24203baf8..000000000 --- a/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingStreamFactory.java +++ /dev/null @@ -1,22 +0,0 @@ -package org.cryptomator.common.streams; - -import java.util.stream.DoubleStream; -import java.util.stream.IntStream; -import java.util.stream.LongStream; -import java.util.stream.Stream; - -public interface DelegatingStreamFactory { - - Stream from(Stream other); - - IntStream from(IntStream other); - - LongStream from(LongStream other); - - DoubleStream from(DoubleStream other); - - public interface ObjectStreamWrapper { - Stream from(Stream other); - } - -} \ No newline at end of file diff --git a/main/commons/src/test/java/org/cryptomator/common/CachingSupplierTest.java b/main/commons/src/test/java/org/cryptomator/common/CachingSupplierTest.java deleted file mode 100644 index 4917c5eac..000000000 --- a/main/commons/src/test/java/org/cryptomator/common/CachingSupplierTest.java +++ /dev/null @@ -1,43 +0,0 @@ -package org.cryptomator.common; - -import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertThat; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -import java.util.function.Supplier; - -import org.junit.Test; - -public class CachingSupplierTest { - - @Test - public void testInvokingGetInvokesDelegate() { - @SuppressWarnings("unchecked") - Supplier delegate = mock(Supplier.class); - Object expectedResult = new Object(); - when(delegate.get()).thenReturn(expectedResult); - Supplier inTest = CachingSupplier.from(delegate); - - Object result = inTest.get(); - - assertThat(result, is(expectedResult)); - } - - @Test - public void testInvokingGetTwiceDoesNotInvokeDelegateTwice() { - @SuppressWarnings("unchecked") - Supplier delegate = mock(Supplier.class); - Object expectedResult = new Object(); - when(delegate.get()).thenReturn(expectedResult); - Supplier inTest = CachingSupplier.from(delegate); - - inTest.get(); - Object result = inTest.get(); - - assertThat(result, is(expectedResult)); - verify(delegate).get(); - } - -} diff --git a/main/commons/src/test/java/org/cryptomator/common/HolderTest.java b/main/commons/src/test/java/org/cryptomator/common/HolderTest.java deleted file mode 100644 index ad71e866f..000000000 --- a/main/commons/src/test/java/org/cryptomator/common/HolderTest.java +++ /dev/null @@ -1,42 +0,0 @@ -package org.cryptomator.common; - -import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertThat; - -import org.junit.Test; - -public class HolderTest { - - private static final Object INITIAL = new Object(); - private static final Object VALUE = new Object(); - - private Holder inTest = new Holder<>(INITIAL); - - @Test - public void testInitialValueIsInitial() { - assertThat(inTest.get(), is(INITIAL)); - } - - @Test - public void testSetChangesValue() { - inTest.set(VALUE); - - assertThat(inTest.get(), is(VALUE)); - } - - @Test - public void testAcceptChangesValue() { - inTest.accept(VALUE); - - assertThat(inTest.get(), is(VALUE)); - } - - @Test - public void testResetChangesValueToInitial() { - inTest.set(VALUE); - inTest.reset(); - - assertThat(inTest.get(), is(INITIAL)); - } - -} diff --git a/main/commons/src/test/java/org/cryptomator/common/WeakValuedCacheTest.java b/main/commons/src/test/java/org/cryptomator/common/WeakValuedCacheTest.java deleted file mode 100644 index d9d1b009d..000000000 --- a/main/commons/src/test/java/org/cryptomator/common/WeakValuedCacheTest.java +++ /dev/null @@ -1,156 +0,0 @@ -package org.cryptomator.common; - -import static java.lang.String.format; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.sameInstance; -import static org.junit.Assert.assertThat; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -import java.util.function.Function; - -import org.junit.Before; -import org.junit.Ignore; -import org.junit.Test; -import org.mockito.Mockito; -import org.mockito.invocation.InvocationOnMock; - -public class WeakValuedCacheTest { - - private final String A_KEY = "aKey"; - private final String ANOTHER_KEY = "anotherKey"; - - private WeakValuedCache inTest; - - private Function loader; - - @SuppressWarnings("unchecked") - @Before - public void setup() { - loader = Mockito.mock(Function.class); - inTest = WeakValuedCache.usingLoader(loader); - } - - @Test - public void testResultOfGetIsResultOfLoaderForTheSameKey() { - Value theValue = new Value(); - Value theOtherValue = new Value(); - when(loader.apply(A_KEY)).thenReturn(theValue); - when(loader.apply(ANOTHER_KEY)).thenReturn(theOtherValue); - - Value result = inTest.get(A_KEY); - Value anotherResult = inTest.get(ANOTHER_KEY); - - assertThat(result, is(sameInstance(theValue))); - assertThat(anotherResult, is(sameInstance(theOtherValue))); - } - - @Test - public void testCachedResultIsResultOfLoaderForTheSameKey() { - Value theValue = new Value(); - Value theOtherValue = new Value(); - when(loader.apply(A_KEY)).thenReturn(theValue); - when(loader.apply(ANOTHER_KEY)).thenReturn(theOtherValue); - - inTest.get(A_KEY); - inTest.get(ANOTHER_KEY); - Value result = inTest.get(A_KEY); - Value anotherResult = inTest.get(ANOTHER_KEY); - - assertThat(result, is(sameInstance(theValue))); - assertThat(anotherResult, is(sameInstance(theOtherValue))); - } - - @Test - public void testTwiceInvocationOfGetDoesNotInvokeLoaderTwice() { - Value theValue = new Value(); - when(loader.apply(A_KEY)).thenReturn(theValue); - - inTest.get(A_KEY); - inTest.get(A_KEY); - - verify(loader).apply(A_KEY); - } - - @Test - public void testSecondInvocationOfGetReturnsTheSameResult() { - Value theValue = new Value(); - when(loader.apply(A_KEY)).thenReturn(theValue); - - inTest.get(A_KEY); - Value result = inTest.get(A_KEY); - - assertThat(result, is(sameInstance(theValue))); - } - - @Ignore - @Test - public void testCacheDoesNotPreventGarbageCollectionOfValues() { - when(loader.apply(A_KEY)).thenAnswer(this::createValueUsingMoreThanHalfTheJvmMemory); - - inTest.get(A_KEY); - - // force garbage collection of previously created value by creating an - // object so large it can not coexist with the value - createObjectUsingMoreThanHalfTheJvmMemory(); - } - - @Test(expected = RuntimeExceptionThrownInLoader.class) - public void testCacheRethrowsRuntimeExceptionsFromLoader() { - when(loader.apply(A_KEY)).thenThrow(new RuntimeExceptionThrownInLoader()); - - inTest.get(A_KEY); - } - - @Test(expected = ErrorThrownInLoader.class) - public void testCacheRethrowsErrorsFromLoader() { - when(loader.apply(A_KEY)).thenThrow(new ErrorThrownInLoader()); - - inTest.get(A_KEY); - } - - private Value createValueUsingMoreThanHalfTheJvmMemory(InvocationOnMock invocation) { - Object data = createObjectUsingMoreThanHalfTheJvmMemory(); - Value value = new Value(); - value.setPayload(data); - return value; - } - - private Object createObjectUsingMoreThanHalfTheJvmMemory() { - long maxMemory = Runtime.getRuntime().maxMemory(); - long moreThanHalfTheJvmMemory = maxMemory / 2 + 1; - return createObjectUsingAtLeast(moreThanHalfTheJvmMemory); - } - - private Object createObjectUsingAtLeast(long minMemory) { - if (minMemory <= Integer.MAX_VALUE) { - return new byte[(int) minMemory]; - } else if ((minMemory / Integer.MAX_VALUE) <= Integer.MAX_VALUE) { - int numberOfArraysWithMaxIntSize = (int) (minMemory / Integer.MAX_VALUE); - int numberOfRemainingBytes = (int) (minMemory - Integer.MAX_VALUE * numberOfArraysWithMaxIntSize); - return new byte[][][] { // - new byte[numberOfArraysWithMaxIntSize][Integer.MAX_VALUE], // - new byte[1][numberOfRemainingBytes] // - }; - } else { - throw new IllegalArgumentException(format("Can not create object with more than 3.999999996 Exabyte")); - } - } - - private static class RuntimeExceptionThrownInLoader extends RuntimeException { - } - - private static class ErrorThrownInLoader extends Error { - } - - private static class Value { - - @SuppressWarnings("unused") - private Object payload; - - public void setPayload(Object payload) { - this.payload = payload; - } - } - -} diff --git a/main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingDoubleStreamTest.java b/main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingDoubleStreamTest.java deleted file mode 100644 index 5a8215ad8..000000000 --- a/main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingDoubleStreamTest.java +++ /dev/null @@ -1,227 +0,0 @@ -package org.cryptomator.common.streams; - -import static org.hamcrest.CoreMatchers.anyOf; -import static org.hamcrest.CoreMatchers.instanceOf; -import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertThat; -import static org.mockito.Mockito.doThrow; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -import java.util.ArrayList; -import java.util.DoubleSummaryStatistics; -import java.util.List; -import java.util.OptionalDouble; -import java.util.function.BiConsumer; -import java.util.function.Consumer; -import java.util.function.DoubleBinaryOperator; -import java.util.function.DoubleConsumer; -import java.util.function.DoubleFunction; -import java.util.function.DoublePredicate; -import java.util.function.DoubleToIntFunction; -import java.util.function.DoubleToLongFunction; -import java.util.function.DoubleUnaryOperator; -import java.util.function.Function; -import java.util.function.ObjDoubleConsumer; -import java.util.function.Supplier; -import java.util.stream.BaseStream; -import java.util.stream.DoubleStream; -import java.util.stream.IntStream; -import java.util.stream.LongStream; -import java.util.stream.Stream; - -import org.hamcrest.Matcher; -import org.junit.Before; -import org.junit.Rule; -import org.junit.experimental.theories.DataPoints; -import org.junit.experimental.theories.FromDataPoints; -import org.junit.experimental.theories.Theories; -import org.junit.experimental.theories.Theory; -import org.junit.rules.ExpectedException; -import org.junit.runner.RunWith; -import org.mockito.InOrder; - -@SuppressWarnings({"unchecked", "rawtypes"}) -@RunWith(Theories.class) -public class AutoClosingDoubleStreamTest { - - private static final DoublePredicate A_DOUBLE_PREDICATE = any -> true; - private static final DoubleFunction A_DOUBLE_FUNCTION = i -> null; - private static final BiConsumer A_BICONSUMER = (a, b) -> { - }; - private static final Supplier A_SUPPLIER = () -> null; - - @DataPoints("intermediateOperations") - public static final List> INTERMEDIATE_OPERATIONS = new ArrayList<>(); - - @DataPoints("terminalOperations") - public static final List> TERMINAL_OPERATIONS = new ArrayList<>(); - private static final DoubleUnaryOperator A_DOUBLE_UNARY_OPERATOR = i -> 3; - private static final DoubleToLongFunction A_DOUBLE_TO_LONG_FUNCTION = i -> 3L; - private static final DoubleToIntFunction A_DOUBLE_TO_INT_FUNCTION = i -> 5; - private static final DoubleConsumer A_DOUBLE_CONSUMER = i -> { - }; - private static final ObjDoubleConsumer AN_OBJ_DOUBLE_CONSUMER = (a, b) -> { - }; - private static final DoubleBinaryOperator A_DOUBLE_BINARY_OPERATOR = (a, b) -> a; - - static { - // define intermediate operations - test(DoubleStream.class, DoubleStream::distinct); - test(DoubleStream.class, stream -> stream.filter(A_DOUBLE_PREDICATE)); - test(DoubleStream.class, stream -> stream.flatMap(A_DOUBLE_FUNCTION)); - test(DoubleStream.class, stream -> stream.limit(5)); - test(DoubleStream.class, stream -> stream.map(A_DOUBLE_UNARY_OPERATOR)); - test(LongStream.class, stream -> stream.mapToLong(A_DOUBLE_TO_LONG_FUNCTION)); - test(Stream.class, stream -> stream.mapToObj(A_DOUBLE_FUNCTION)); - test(IntStream.class, stream -> stream.mapToInt(A_DOUBLE_TO_INT_FUNCTION)); - test(DoubleStream.class, DoubleStream::parallel); - test(DoubleStream.class, stream -> stream.peek(A_DOUBLE_CONSUMER)); - test(DoubleStream.class, DoubleStream::sequential); - test(DoubleStream.class, stream -> stream.skip(5)); - test(DoubleStream.class, DoubleStream::sorted); - test(DoubleStream.class, DoubleStream::unordered); - test(Stream.class, DoubleStream::boxed); - - // define terminal operations - test(stream -> stream.allMatch(A_DOUBLE_PREDICATE), true); - test(stream -> stream.anyMatch(A_DOUBLE_PREDICATE), true); - test(stream -> stream.collect(A_SUPPLIER, AN_OBJ_DOUBLE_CONSUMER, A_BICONSUMER), 7d); - test(DoubleStream::count, 3L); - test(DoubleStream::findAny, OptionalDouble.of(3)); - test(DoubleStream::findFirst, OptionalDouble.of(3)); - test(stream -> stream.forEach(A_DOUBLE_CONSUMER)); - test(stream -> stream.forEachOrdered(A_DOUBLE_CONSUMER)); - test(stream -> stream.max(), OptionalDouble.of(3)); - test(stream -> stream.min(), OptionalDouble.of(3)); - test(stream -> stream.noneMatch(A_DOUBLE_PREDICATE), true); - test(stream -> stream.reduce(A_DOUBLE_BINARY_OPERATOR), OptionalDouble.of(3)); - test(stream -> stream.reduce(1, A_DOUBLE_BINARY_OPERATOR), 3d); - test(DoubleStream::toArray, new double[1]); - test(DoubleStream::sum, 1d); - test(DoubleStream::average, OptionalDouble.of(3d)); - test(DoubleStream::summaryStatistics, new DoubleSummaryStatistics()); - } - - private static void test(Consumer consumer) { - TERMINAL_OPERATIONS.add(new TerminalOperation() { - @Override - public T result() { - return null; - } - - @Override - public T apply(DoubleStream stream) { - consumer.accept(stream); - return null; - } - }); - } - - private static void test(Function function, T result) { - TERMINAL_OPERATIONS.add(new TerminalOperation() { - @Override - public T result() { - return result; - } - - @Override - public T apply(DoubleStream stream) { - return function.apply(stream); - } - }); - } - - private static void test(Class type, Function function) { - INTERMEDIATE_OPERATIONS.add(new DoubleermediateOperation() { - @Override - public Class type() { - return type; - } - - @Override - public T apply(DoubleStream stream) { - return function.apply(stream); - } - }); - } - - @Rule - public ExpectedException thrown = ExpectedException.none(); - - private DoubleStream delegate; - private DoubleStream inTest; - - @Before - public void setUp() { - delegate = mock(DoubleStream.class); - inTest = AutoClosingDoubleStream.from(delegate); - } - - @Theory - public void testIntermediateOperationReturnsNewAutoClosingStream(@FromDataPoints("intermediateOperations") DoubleermediateOperation intermediateOperation) { - BaseStream newDelegate = (BaseStream) mock(intermediateOperation.type()); - when(intermediateOperation.apply(delegate)).thenReturn(newDelegate); - - BaseStream result = intermediateOperation.apply(inTest); - - assertThat(result, isAutoClosing()); - verifyDelegate(result, newDelegate); - } - - @Theory - public void testTerminalOperationDelegatesToAndClosesDelegate(@FromDataPoints("terminalOperations") TerminalOperation terminalOperation) { - Object expectedResult = terminalOperation.result(); - if (expectedResult != null) { - when(terminalOperation.apply(delegate)).thenReturn(expectedResult); - } - - Object result = terminalOperation.apply(inTest); - - InOrder inOrder = inOrder(delegate); - assertThat(result, is(expectedResult)); - inOrder.verify(delegate).close(); - } - - @Theory - public void testTerminalOperationClosesDelegateEvenOnException(@FromDataPoints("terminalOperations") TerminalOperation terminalOperation) { - RuntimeException exception = new RuntimeException(); - terminalOperation.apply(doThrow(exception).when(delegate)); - - thrown.expect(is(exception)); - - try { - terminalOperation.apply(inTest); - } finally { - verify(delegate).close(); - } - } - - private Matcher isAutoClosing() { - return is(anyOf(instanceOf(AutoClosingStream.class), instanceOf(AutoClosingDoubleStream.class), instanceOf(AutoClosingIntStream.class), instanceOf(AutoClosingLongStream.class))); - } - - private void verifyDelegate(BaseStream result, BaseStream newDelegate) { - result.close(); - verify(newDelegate).close(); - } - - private interface TerminalOperation { - - T result(); - - T apply(DoubleStream stream); - - } - - private interface DoubleermediateOperation { - - Class type(); - - T apply(DoubleStream stream); - - } - -} diff --git a/main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingIntStreamTest.java b/main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingIntStreamTest.java deleted file mode 100644 index d86718b62..000000000 --- a/main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingIntStreamTest.java +++ /dev/null @@ -1,228 +0,0 @@ -package org.cryptomator.common.streams; - -import static org.hamcrest.CoreMatchers.anyOf; -import static org.hamcrest.CoreMatchers.instanceOf; -import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertThat; -import static org.mockito.Mockito.doThrow; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -import java.util.ArrayList; -import java.util.IntSummaryStatistics; -import java.util.List; -import java.util.OptionalDouble; -import java.util.OptionalInt; -import java.util.function.BiConsumer; -import java.util.function.Consumer; -import java.util.function.Function; -import java.util.function.IntBinaryOperator; -import java.util.function.IntConsumer; -import java.util.function.IntFunction; -import java.util.function.IntPredicate; -import java.util.function.IntToDoubleFunction; -import java.util.function.IntToLongFunction; -import java.util.function.IntUnaryOperator; -import java.util.function.ObjIntConsumer; -import java.util.function.Supplier; -import java.util.stream.BaseStream; -import java.util.stream.DoubleStream; -import java.util.stream.IntStream; -import java.util.stream.LongStream; -import java.util.stream.Stream; - -import org.hamcrest.Matcher; -import org.junit.Before; -import org.junit.Rule; -import org.junit.experimental.theories.DataPoints; -import org.junit.experimental.theories.FromDataPoints; -import org.junit.experimental.theories.Theories; -import org.junit.experimental.theories.Theory; -import org.junit.rules.ExpectedException; -import org.junit.runner.RunWith; -import org.mockito.InOrder; - -@SuppressWarnings({"unchecked", "rawtypes"}) -@RunWith(Theories.class) -public class AutoClosingIntStreamTest { - - private static final IntPredicate AN_INT_PREDICATE = any -> true; - private static final IntFunction AN_INT_FUNCTION = i -> null; - private static final BiConsumer A_BICONSUMER = (a, b) -> { - }; - private static final Supplier A_SUPPLIER = () -> null; - - @DataPoints("intermediateOperations") - public static final List> INTERMEDIATE_OPERATIONS = new ArrayList<>(); - - @DataPoints("terminalOperations") - public static final List> TERMINAL_OPERATIONS = new ArrayList<>(); - private static final IntUnaryOperator AN_INT_UNARY_OPERATOR = i -> 3; - private static final IntToDoubleFunction AN_INT_TO_DOUBLE_FUNCTION = i -> 3d; - private static final IntToLongFunction AN_INT_TO_LONG_FUNCTION = i -> 5L; - private static final IntConsumer AN_INT_CONSUMER = i -> { - }; - private static final ObjIntConsumer AN_OBJ_INT_CONSUMER = (a, b) -> { - }; - private static final IntBinaryOperator AN_INT_BINARY_OPERATOR = (a, b) -> a; - - static { - // define intermediate operations - test(IntStream.class, IntStream::distinct); - test(IntStream.class, stream -> stream.filter(AN_INT_PREDICATE)); - test(IntStream.class, stream -> stream.flatMap(AN_INT_FUNCTION)); - test(IntStream.class, stream -> stream.limit(5)); - test(IntStream.class, stream -> stream.map(AN_INT_UNARY_OPERATOR)); - test(DoubleStream.class, stream -> stream.mapToDouble(AN_INT_TO_DOUBLE_FUNCTION)); - test(Stream.class, stream -> stream.mapToObj(AN_INT_FUNCTION)); - test(LongStream.class, stream -> stream.mapToLong(AN_INT_TO_LONG_FUNCTION)); - test(IntStream.class, IntStream::parallel); - test(IntStream.class, stream -> stream.peek(AN_INT_CONSUMER)); - test(IntStream.class, IntStream::sequential); - test(IntStream.class, stream -> stream.skip(5)); - test(IntStream.class, IntStream::sorted); - test(IntStream.class, IntStream::unordered); - test(Stream.class, IntStream::boxed); - - // define terminal operations - test(stream -> stream.allMatch(AN_INT_PREDICATE), true); - test(stream -> stream.anyMatch(AN_INT_PREDICATE), true); - test(stream -> stream.collect(A_SUPPLIER, AN_OBJ_INT_CONSUMER, A_BICONSUMER), 7); - test(IntStream::count, 3L); - test(IntStream::findAny, OptionalInt.of(3)); - test(IntStream::findFirst, OptionalInt.of(3)); - test(stream -> stream.forEach(AN_INT_CONSUMER)); - test(stream -> stream.forEachOrdered(AN_INT_CONSUMER)); - test(stream -> stream.max(), OptionalInt.of(3)); - test(stream -> stream.min(), OptionalInt.of(3)); - test(stream -> stream.noneMatch(AN_INT_PREDICATE), true); - test(stream -> stream.reduce(AN_INT_BINARY_OPERATOR), OptionalInt.of(3)); - test(stream -> stream.reduce(1, AN_INT_BINARY_OPERATOR), 3); - test(IntStream::toArray, new int[1]); - test(IntStream::sum, 1); - test(IntStream::average, OptionalDouble.of(3d)); - test(IntStream::summaryStatistics, new IntSummaryStatistics()); - } - - private static void test(Consumer consumer) { - TERMINAL_OPERATIONS.add(new TerminalOperation() { - @Override - public T result() { - return null; - } - - @Override - public T apply(IntStream stream) { - consumer.accept(stream); - return null; - } - }); - } - - private static void test(Function function, T result) { - TERMINAL_OPERATIONS.add(new TerminalOperation() { - @Override - public T result() { - return result; - } - - @Override - public T apply(IntStream stream) { - return function.apply(stream); - } - }); - } - - private static void test(Class type, Function function) { - INTERMEDIATE_OPERATIONS.add(new IntermediateOperation() { - @Override - public Class type() { - return type; - } - - @Override - public T apply(IntStream stream) { - return function.apply(stream); - } - }); - } - - @Rule - public ExpectedException thrown = ExpectedException.none(); - - private IntStream delegate; - private IntStream inTest; - - @Before - public void setUp() { - delegate = mock(IntStream.class); - inTest = AutoClosingIntStream.from(delegate); - } - - @Theory - public void testIntermediateOperationReturnsNewAutoClosingStream(@FromDataPoints("intermediateOperations") IntermediateOperation intermediateOperation) { - BaseStream newDelegate = (BaseStream) mock(intermediateOperation.type()); - when(intermediateOperation.apply(delegate)).thenReturn(newDelegate); - - BaseStream result = intermediateOperation.apply(inTest); - - assertThat(result, isAutoClosing()); - verifyDelegate(result, newDelegate); - } - - @Theory - public void testTerminalOperationDelegatesToAndClosesDelegate(@FromDataPoints("terminalOperations") TerminalOperation terminalOperation) { - Object expectedResult = terminalOperation.result(); - if (expectedResult != null) { - when(terminalOperation.apply(delegate)).thenReturn(expectedResult); - } - - Object result = terminalOperation.apply(inTest); - - InOrder inOrder = inOrder(delegate); - assertThat(result, is(expectedResult)); - inOrder.verify(delegate).close(); - } - - @Theory - public void testTerminalOperationClosesDelegateEvenOnException(@FromDataPoints("terminalOperations") TerminalOperation terminalOperation) { - RuntimeException exception = new RuntimeException(); - terminalOperation.apply(doThrow(exception).when(delegate)); - - thrown.expect(is(exception)); - - try { - terminalOperation.apply(inTest); - } finally { - verify(delegate).close(); - } - } - - private Matcher isAutoClosing() { - return is(anyOf(instanceOf(AutoClosingStream.class), instanceOf(AutoClosingDoubleStream.class), instanceOf(AutoClosingIntStream.class), instanceOf(AutoClosingLongStream.class))); - } - - private void verifyDelegate(BaseStream result, BaseStream newDelegate) { - result.close(); - verify(newDelegate).close(); - } - - private interface TerminalOperation { - - T result(); - - T apply(IntStream stream); - - } - - private interface IntermediateOperation { - - Class type(); - - T apply(IntStream stream); - - } - -} diff --git a/main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingLongStreamTest.java b/main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingLongStreamTest.java deleted file mode 100644 index 02601f231..000000000 --- a/main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingLongStreamTest.java +++ /dev/null @@ -1,228 +0,0 @@ -package org.cryptomator.common.streams; - -import static org.hamcrest.CoreMatchers.anyOf; -import static org.hamcrest.CoreMatchers.instanceOf; -import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertThat; -import static org.mockito.Mockito.doThrow; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -import java.util.ArrayList; -import java.util.List; -import java.util.LongSummaryStatistics; -import java.util.OptionalDouble; -import java.util.OptionalLong; -import java.util.function.BiConsumer; -import java.util.function.Consumer; -import java.util.function.Function; -import java.util.function.LongBinaryOperator; -import java.util.function.LongConsumer; -import java.util.function.LongFunction; -import java.util.function.LongPredicate; -import java.util.function.LongToDoubleFunction; -import java.util.function.LongToIntFunction; -import java.util.function.LongUnaryOperator; -import java.util.function.ObjLongConsumer; -import java.util.function.Supplier; -import java.util.stream.BaseStream; -import java.util.stream.DoubleStream; -import java.util.stream.IntStream; -import java.util.stream.LongStream; -import java.util.stream.Stream; - -import org.hamcrest.Matcher; -import org.junit.Before; -import org.junit.Rule; -import org.junit.experimental.theories.DataPoints; -import org.junit.experimental.theories.FromDataPoints; -import org.junit.experimental.theories.Theories; -import org.junit.experimental.theories.Theory; -import org.junit.rules.ExpectedException; -import org.junit.runner.RunWith; -import org.mockito.InOrder; - -@SuppressWarnings({"unchecked", "rawtypes"}) -@RunWith(Theories.class) -public class AutoClosingLongStreamTest { - - private static final LongPredicate AN_LONG_PREDICATE = any -> true; - private static final LongFunction AN_LONG_FUNCTION = i -> null; - private static final BiConsumer A_BICONSUMER = (a, b) -> { - }; - private static final Supplier A_SUPPLIER = () -> null; - - @DataPoints("intermediateOperations") - public static final List> INTERMEDIATE_OPERATIONS = new ArrayList<>(); - - @DataPoints("terminalOperations") - public static final List> TERMINAL_OPERATIONS = new ArrayList<>(); - private static final LongUnaryOperator AN_LONG_UNARY_OPERATOR = i -> 3; - private static final LongToDoubleFunction AN_LONG_TO_DOUBLE_FUNCTION = i -> 3d; - private static final LongToIntFunction AN_LONG_TO_INT_FUNCTION = i -> 5; - private static final LongConsumer AN_LONG_CONSUMER = i -> { - }; - private static final ObjLongConsumer AN_OBJ_LONG_CONSUMER = (a, b) -> { - }; - private static final LongBinaryOperator AN_LONG_BINARY_OPERATOR = (a, b) -> a; - - static { - // define intermediate operations - test(LongStream.class, LongStream::distinct); - test(LongStream.class, stream -> stream.filter(AN_LONG_PREDICATE)); - test(LongStream.class, stream -> stream.flatMap(AN_LONG_FUNCTION)); - test(LongStream.class, stream -> stream.limit(5)); - test(LongStream.class, stream -> stream.map(AN_LONG_UNARY_OPERATOR)); - test(DoubleStream.class, stream -> stream.mapToDouble(AN_LONG_TO_DOUBLE_FUNCTION)); - test(Stream.class, stream -> stream.mapToObj(AN_LONG_FUNCTION)); - test(IntStream.class, stream -> stream.mapToInt(AN_LONG_TO_INT_FUNCTION)); - test(LongStream.class, LongStream::parallel); - test(LongStream.class, stream -> stream.peek(AN_LONG_CONSUMER)); - test(LongStream.class, LongStream::sequential); - test(LongStream.class, stream -> stream.skip(5)); - test(LongStream.class, LongStream::sorted); - test(LongStream.class, LongStream::unordered); - test(Stream.class, LongStream::boxed); - - // define terminal operations - test(stream -> stream.allMatch(AN_LONG_PREDICATE), true); - test(stream -> stream.anyMatch(AN_LONG_PREDICATE), true); - test(stream -> stream.collect(A_SUPPLIER, AN_OBJ_LONG_CONSUMER, A_BICONSUMER), 7L); - test(LongStream::count, 3L); - test(LongStream::findAny, OptionalLong.of(3)); - test(LongStream::findFirst, OptionalLong.of(3)); - test(stream -> stream.forEach(AN_LONG_CONSUMER)); - test(stream -> stream.forEachOrdered(AN_LONG_CONSUMER)); - test(stream -> stream.max(), OptionalLong.of(3)); - test(stream -> stream.min(), OptionalLong.of(3)); - test(stream -> stream.noneMatch(AN_LONG_PREDICATE), true); - test(stream -> stream.reduce(AN_LONG_BINARY_OPERATOR), OptionalLong.of(3)); - test(stream -> stream.reduce(1, AN_LONG_BINARY_OPERATOR), 3L); - test(LongStream::toArray, new long[1]); - test(LongStream::sum, 1L); - test(LongStream::average, OptionalDouble.of(3d)); - test(LongStream::summaryStatistics, new LongSummaryStatistics()); - } - - private static void test(Consumer consumer) { - TERMINAL_OPERATIONS.add(new TerminalOperation() { - @Override - public T result() { - return null; - } - - @Override - public T apply(LongStream stream) { - consumer.accept(stream); - return null; - } - }); - } - - private static void test(Function function, T result) { - TERMINAL_OPERATIONS.add(new TerminalOperation() { - @Override - public T result() { - return result; - } - - @Override - public T apply(LongStream stream) { - return function.apply(stream); - } - }); - } - - private static void test(Class type, Function function) { - INTERMEDIATE_OPERATIONS.add(new LongermediateOperation() { - @Override - public Class type() { - return type; - } - - @Override - public T apply(LongStream stream) { - return function.apply(stream); - } - }); - } - - @Rule - public ExpectedException thrown = ExpectedException.none(); - - private LongStream delegate; - private LongStream inTest; - - @Before - public void setUp() { - delegate = mock(LongStream.class); - inTest = AutoClosingLongStream.from(delegate); - } - - @Theory - public void testIntermediateOperationReturnsNewAutoClosingStream(@FromDataPoints("intermediateOperations") LongermediateOperation intermediateOperation) { - BaseStream newDelegate = (BaseStream) mock(intermediateOperation.type()); - when(intermediateOperation.apply(delegate)).thenReturn(newDelegate); - - BaseStream result = intermediateOperation.apply(inTest); - - assertThat(result, isAutoClosing()); - verifyDelegate(result, newDelegate); - } - - @Theory - public void testTerminalOperationDelegatesToAndClosesDelegate(@FromDataPoints("terminalOperations") TerminalOperation terminalOperation) { - Object expectedResult = terminalOperation.result(); - if (expectedResult != null) { - when(terminalOperation.apply(delegate)).thenReturn(expectedResult); - } - - Object result = terminalOperation.apply(inTest); - - InOrder inOrder = inOrder(delegate); - assertThat(result, is(expectedResult)); - inOrder.verify(delegate).close(); - } - - @Theory - public void testTerminalOperationClosesDelegateEvenOnException(@FromDataPoints("terminalOperations") TerminalOperation terminalOperation) { - RuntimeException exception = new RuntimeException(); - terminalOperation.apply(doThrow(exception).when(delegate)); - - thrown.expect(is(exception)); - - try { - terminalOperation.apply(inTest); - } finally { - verify(delegate).close(); - } - } - - private Matcher isAutoClosing() { - return is(anyOf(instanceOf(AutoClosingStream.class), instanceOf(AutoClosingDoubleStream.class), instanceOf(AutoClosingIntStream.class), instanceOf(AutoClosingLongStream.class))); - } - - private void verifyDelegate(BaseStream result, BaseStream newDelegate) { - result.close(); - verify(newDelegate).close(); - } - - private interface TerminalOperation { - - T result(); - - T apply(LongStream stream); - - } - - private interface LongermediateOperation { - - Class type(); - - T apply(LongStream stream); - - } - -} diff --git a/main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingStreamTest.java b/main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingStreamTest.java deleted file mode 100644 index 5f9f27fc8..000000000 --- a/main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingStreamTest.java +++ /dev/null @@ -1,231 +0,0 @@ -package org.cryptomator.common.streams; - -import static org.hamcrest.CoreMatchers.anyOf; -import static org.hamcrest.CoreMatchers.instanceOf; -import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertThat; -import static org.mockito.Mockito.doThrow; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -import java.util.ArrayList; -import java.util.Comparator; -import java.util.List; -import java.util.Optional; -import java.util.function.BiConsumer; -import java.util.function.BinaryOperator; -import java.util.function.Consumer; -import java.util.function.Function; -import java.util.function.IntFunction; -import java.util.function.Predicate; -import java.util.function.Supplier; -import java.util.function.ToDoubleFunction; -import java.util.function.ToIntFunction; -import java.util.function.ToLongFunction; -import java.util.stream.BaseStream; -import java.util.stream.Collector; -import java.util.stream.DoubleStream; -import java.util.stream.IntStream; -import java.util.stream.LongStream; -import java.util.stream.Stream; - -import org.hamcrest.Matcher; -import org.junit.Before; -import org.junit.Rule; -import org.junit.experimental.theories.DataPoints; -import org.junit.experimental.theories.FromDataPoints; -import org.junit.experimental.theories.Theories; -import org.junit.experimental.theories.Theory; -import org.junit.rules.ExpectedException; -import org.junit.runner.RunWith; -import org.mockito.InOrder; - -@SuppressWarnings({"unchecked", "rawtypes"}) -@RunWith(Theories.class) -public class AutoClosingStreamTest { - - private static final Predicate A_PREDICATE = any -> true; - private static final Function A_FUNCTION = any -> null; - private static final ToDoubleFunction A_TO_DOUBLE_FUNCTION = any -> 0d; - private static final ToIntFunction A_TO_INT_FUNCTION = any -> 1; - private static final ToLongFunction A_TO_LONG_FUNCTION = any -> 1L; - private static final Consumer A_CONSUMER = any -> { - }; - private static final Comparator A_COMPARATOR = (left, right) -> 0; - private static final Collector A_COLLECTOR = mock(Collector.class); - private static final BinaryOperator A_BINARY_OPERATOR = (left, right) -> null; - private static final Object AN_OBJECT = new Object(); - private static final IntFunction AN_INT_FUNCTION = i -> null; - private static final BiConsumer A_BICONSUMER = (a, b) -> { - }; - private static final Supplier A_SUPPLIER = () -> null; - - @DataPoints("intermediateOperations") - public static final List> INTERMEDIATE_OPERATIONS = new ArrayList<>(); - - @DataPoints("terminalOperations") - public static final List> TERMINAL_OPERATIONS = new ArrayList<>(); - - static { - // define intermediate operations - test(Stream.class, Stream::distinct); - test(Stream.class, stream -> stream.filter(A_PREDICATE)); - test(Stream.class, stream -> stream.flatMap(A_FUNCTION)); - test(DoubleStream.class, stream -> stream.flatMapToDouble(A_FUNCTION)); - test(IntStream.class, stream -> stream.flatMapToInt(A_FUNCTION)); - test(LongStream.class, stream -> stream.flatMapToLong(A_FUNCTION)); - test(Stream.class, stream -> stream.limit(5)); - test(Stream.class, stream -> stream.map(A_FUNCTION)); - test(DoubleStream.class, stream -> stream.mapToDouble(A_TO_DOUBLE_FUNCTION)); - test(IntStream.class, stream -> stream.mapToInt(A_TO_INT_FUNCTION)); - test(LongStream.class, stream -> stream.mapToLong(A_TO_LONG_FUNCTION)); - test(Stream.class, Stream::parallel); - test(Stream.class, stream -> stream.peek(A_CONSUMER)); - test(Stream.class, Stream::sequential); - test(Stream.class, stream -> stream.skip(5)); - test(Stream.class, Stream::sorted); - test(Stream.class, stream -> stream.sorted(A_COMPARATOR)); - test(Stream.class, Stream::unordered); - - // define terminal operations - test(stream -> stream.allMatch(A_PREDICATE), true); - test(stream -> stream.anyMatch(A_PREDICATE), true); - test(stream -> stream.collect(A_COLLECTOR), new Object()); - test(stream -> stream.collect(A_SUPPLIER, A_BICONSUMER, A_BICONSUMER), new Object()); - test(Stream::count, 3L); - test(Stream::findAny, Optional.of(new Object())); - test(Stream::findFirst, Optional.of(new Object())); - test(stream -> stream.forEach(A_CONSUMER)); - test(stream -> stream.forEachOrdered(A_CONSUMER)); - test(stream -> stream.max(A_COMPARATOR), Optional.of(new Object())); - test(stream -> stream.min(A_COMPARATOR), Optional.of(new Object())); - test(stream -> stream.noneMatch(A_PREDICATE), true); - test(stream -> stream.reduce(A_BINARY_OPERATOR), Optional.of(new Object())); - test(stream -> stream.reduce(AN_OBJECT, A_BINARY_OPERATOR), Optional.of(new Object())); - test(stream -> stream.reduce(AN_OBJECT, A_BINARY_OPERATOR, A_BINARY_OPERATOR), Optional.of(new Object())); - test(Stream::toArray, new Object[1]); - test(stream -> stream.toArray(AN_INT_FUNCTION), new Object[1]); - } - - private static void test(Consumer consumer) { - TERMINAL_OPERATIONS.add(new TerminalOperation() { - @Override - public T result() { - return null; - } - - @Override - public T apply(Stream stream) { - consumer.accept(stream); - return null; - } - }); - } - - private static void test(Function function, T result) { - TERMINAL_OPERATIONS.add(new TerminalOperation() { - @Override - public T result() { - return result; - } - - @Override - public T apply(Stream stream) { - return function.apply(stream); - } - }); - } - - private static void test(Class type, Function function) { - INTERMEDIATE_OPERATIONS.add(new IntermediateOperation() { - @Override - public Class type() { - return type; - } - - @Override - public T apply(Stream stream) { - return function.apply(stream); - } - }); - } - - @Rule - public ExpectedException thrown = ExpectedException.none(); - - private Stream delegate; - private Stream inTest; - - @Before - public void setUp() { - delegate = mock(Stream.class); - inTest = AutoClosingStream.from(delegate); - } - - @Theory - public void testIntermediateOperationReturnsNewAutoClosingStream(@FromDataPoints("intermediateOperations") IntermediateOperation intermediateOperation) { - BaseStream newDelegate = (BaseStream) mock(intermediateOperation.type()); - when(intermediateOperation.apply(delegate)).thenReturn(newDelegate); - - BaseStream result = intermediateOperation.apply(inTest); - - assertThat(result, isAutoClosing()); - verifyDelegate(result, newDelegate); - } - - @Theory - public void testTerminalOperationDelegatesToAndClosesDelegate(@FromDataPoints("terminalOperations") TerminalOperation terminalOperation) { - Object expectedResult = terminalOperation.result(); - if (expectedResult != null) { - when(terminalOperation.apply(delegate)).thenReturn(expectedResult); - } - - Object result = terminalOperation.apply(inTest); - - InOrder inOrder = inOrder(delegate); - assertThat(result, is(expectedResult)); - inOrder.verify(delegate).close(); - } - - @Theory - public void testTerminalOperationClosesDelegateEvenOnException(@FromDataPoints("terminalOperations") TerminalOperation terminalOperation) { - RuntimeException exception = new RuntimeException(); - terminalOperation.apply(doThrow(exception).when(delegate)); - - thrown.expect(is(exception)); - - try { - terminalOperation.apply(inTest); - } finally { - verify(delegate).close(); - } - } - - private Matcher isAutoClosing() { - return is(anyOf(instanceOf(AutoClosingStream.class), instanceOf(AutoClosingDoubleStream.class), instanceOf(AutoClosingIntStream.class), instanceOf(AutoClosingLongStream.class))); - } - - private void verifyDelegate(BaseStream result, BaseStream newDelegate) { - result.close(); - verify(newDelegate).close(); - } - - private interface TerminalOperation { - - T result(); - - T apply(Stream stream); - - } - - private interface IntermediateOperation { - - Class type(); - - T apply(Stream stream); - - } - -}