mirrors/cryptomator
1
0
Fork 0
mirror of https://github.com/cryptomator/cryptomator.git synced 2026-05-20 11:41:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

Removed unused classes

Browse Source
This commit is contained in:
Sebastian Stenzel
2017-05-12 12:06:28 +02:00
parent fdccafaa68
commit dbc803a0d9
21 changed files with 0 additions and 2846 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
main/commons/src/main/java/org/cryptomator/common/CachingSupplier.java
View File

@@ -1,26 +0,0 @@
package org.cryptomator.common;
import java.util.function.Supplier;
public class CachingSupplier<T> implements Supplier<T> {
public static <T> Supplier<T> from(Supplier<T> delegate) {
return new CachingSupplier<>(delegate);
}
private Supplier<T> delegate;
private CachingSupplier(Supplier<T> delegate) {
this.delegate = () -> {
T result = delegate.get();
CachingSupplier.this.delegate = () -> result;
return result;
};
}
@Override
public T get() {
return delegate.get();
}
}

34
main/commons/src/main/java/org/cryptomator/common/Holder.java
View File

@@ -1,34 +0,0 @@
package org.cryptomator.common;
import java.util.function.Consumer;
import java.util.function.Supplier;
public class Holder<V> implements Supplier<V>, Consumer<V> {
private final V initial;
private V value;
public <W extends V> 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);
}
}

56
main/commons/src/main/java/org/cryptomator/common/StackTrace.java
View File

@@ -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(')');
}
}

48
main/commons/src/main/java/org/cryptomator/common/WeakValuedCache.java
View File

@@ -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<Key, Value> {
private final LoadingCache<Key, Value> delegate;
private WeakValuedCache(Function<Key, Value> loader) {
delegate = CacheBuilder.newBuilder() //
.weakValues() //
.build(new CacheLoader<Key, Value>() {
@Override
public Value load(Key key) {
return loader.apply(key);
}
});
}
public static <Key, Value> WeakValuedCache<Key, Value> usingLoader(Function<Key, Value> 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<Key, Value> function) {
delegate.asMap().forEach(function);
}
}

178
main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingDoubleStream.java
View File

@@ -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> R collect(Supplier<R> supplier, ObjDoubleConsumer<R> accumulator, BiConsumer<R, R> 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();
}
}
}

179
main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingIntStream.java
View File

@@ -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> R collect(Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R, R> 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();
}
}
}

179
main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingLongStream.java
View File

@@ -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> R collect(Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R, R> 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();
}
}
}

173
main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingStream.java
View File

@@ -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;
/**
* <p>
* A Stream which is automatically closed after execution of a terminal operation.
* <p>
* Streams returned by intermediate operations are also auto closing.
* <p>
* <b>Note:</b> When using {@link #iterator()} or {@link #spliterator()} auto closing does not occur.
*
* @author Markus Kreusch
*/
public class AutoClosingStream<T> extends DelegatingStream<T> {
public static <T> Stream<T> from(Stream<T> delegate) {
return new AutoClosingStream<>(delegate);
}
private AutoClosingStream(Stream<T> delegate) {
super(delegate, AUTO_CLOSING_STREAM_FACTORY);
}
public void forEach(Consumer<? super T> action) {
try {
super.forEach(action);
} finally {
close();
}
}
public void forEachOrdered(Consumer<? super T> action) {
try {
super.forEachOrdered(action);
} finally {
close();
}
}
public Object[] toArray() {
try {
return super.toArray();
} finally {
close();
}
}
public <A> A[] toArray(IntFunction<A[]> generator) {
try {
return super.toArray(generator);
} finally {
close();
}
}
public T reduce(T identity, BinaryOperator<T> accumulator) {
try {
return super.reduce(identity, accumulator);
} finally {
close();
}
}
public Optional<T> reduce(BinaryOperator<T> accumulator) {
try {
return super.reduce(accumulator);
} finally {
close();
}
}
public <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner) {
try {
return super.reduce(identity, accumulator, combiner);
} finally {
close();
}
}
public <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner) {
try {
return super.collect(supplier, accumulator, combiner);
} finally {
close();
}
}
public <R, A> R collect(Collector<? super T, A, R> collector) {
try {
return super.collect(collector);
} finally {
close();
}
}
public Optional<T> min(Comparator<? super T> comparator) {
try {
return super.min(comparator);
} finally {
close();
}
}
public Optional<T> max(Comparator<? super T> comparator) {
try {
return super.max(comparator);
} finally {
close();
}
}
public long count() {
try {
return super.count();
} finally {
close();
}
}
public boolean anyMatch(Predicate<? super T> predicate) {
try {
return super.anyMatch(predicate);
} finally {
close();
}
}
public boolean allMatch(Predicate<? super T> predicate) {
try {
return super.allMatch(predicate);
} finally {
close();
}
}
public boolean noneMatch(Predicate<? super T> predicate) {
try {
return super.noneMatch(predicate);
} finally {
close();
}
}
public Optional<T> findFirst() {
try {
return super.findFirst();
} finally {
close();
}
}
public Optional<T> findAny() {
try {
return super.findAny();
} finally {
close();
}
}
}

51
main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingStreamFactory.java
View File

@@ -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 <S> Stream<S> from(Stream<S> 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);
}
}
}

179
main/commons/src/main/java/org/cryptomator/common/streams/DelegatingDoubleStream.java
View File

@@ -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 <U> Stream<U> mapToObj(DoubleFunction<? extends U> 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<? extends DoubleStream> 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> R collect(Supplier<R> supplier, ObjDoubleConsumer<R> accumulator, BiConsumer<R, R> 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<Double> 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();
}
}

188
main/commons/src/main/java/org/cryptomator/common/streams/DelegatingIntStream.java
View File

@@ -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 <U> Stream<U> mapToObj(IntFunction<? extends U> 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<? extends IntStream> 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> R collect(Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R, R> 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<Integer> 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();
}
}

184
main/commons/src/main/java/org/cryptomator/common/streams/DelegatingLongStream.java
View File

@@ -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 <U> Stream<U> mapToObj(LongFunction<? extends U> 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<? extends LongStream> 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> R collect(Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R, R> 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<Long> 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();
}
}

194
main/commons/src/main/java/org/cryptomator/common/streams/DelegatingStream.java
View File

@@ -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<T> implements Stream<T> {
private final Stream<T> delegate;
private final DelegatingStreamFactory wrapper;
protected DelegatingStream(Stream<T> delegate, DelegatingStreamFactory wrapper) {
this.delegate = delegate;
this.wrapper = wrapper;
}
public Iterator<T> iterator() {
return delegate.iterator();
}
public Spliterator<T> spliterator() {
return delegate.spliterator();
}
public boolean isParallel() {
return delegate.isParallel();
}
public Stream<T> sequential() {
return wrapper.from(delegate.sequential());
}
public Stream<T> parallel() {
return wrapper.from(delegate.parallel());
}
public Stream<T> unordered() {
return wrapper.from(delegate.unordered());
}
public Stream<T> onClose(Runnable closeHandler) {
return wrapper.from(delegate.onClose(closeHandler));
}
public void close() {
delegate.close();
}
public Stream<T> filter(Predicate<? super T> predicate) {
return wrapper.from(delegate.filter(predicate));
}
public <R> Stream<R> map(Function<? super T, ? extends R> mapper) {
return wrapper.from(delegate.map(mapper));
}
public IntStream mapToInt(ToIntFunction<? super T> mapper) {
return wrapper.from(delegate.mapToInt(mapper));
}
public LongStream mapToLong(ToLongFunction<? super T> mapper) {
return wrapper.from(delegate.mapToLong(mapper));
}
public DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper) {
return wrapper.from(delegate.mapToDouble(mapper));
}
public <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) {
return wrapper.from(delegate.flatMap(mapper));
}
public IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper) {
return wrapper.from(delegate.flatMapToInt(mapper));
}
public LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper) {
return wrapper.from(delegate.flatMapToLong(mapper));
}
public DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper) {
return wrapper.from(delegate.flatMapToDouble(mapper));
}
public Stream<T> distinct() {
return wrapper.from(delegate.distinct());
}
public Stream<T> sorted() {
return wrapper.from(delegate.sorted());
}
public Stream<T> sorted(Comparator<? super T> comparator) {
return wrapper.from(delegate.sorted(comparator));
}
public Stream<T> peek(Consumer<? super T> action) {
return wrapper.from(delegate.peek(action));
}
public Stream<T> limit(long maxSize) {
return wrapper.from(delegate.limit(maxSize));
}
public Stream<T> skip(long n) {
return wrapper.from(delegate.skip(n));
}
public void forEach(Consumer<? super T> action) {
delegate.forEach(action);
}
public void forEachOrdered(Consumer<? super T> action) {
delegate.forEachOrdered(action);
}
public Object[] toArray() {
return delegate.toArray();
}
public <A> A[] toArray(IntFunction<A[]> generator) {
return delegate.toArray(generator);
}
public T reduce(T identity, BinaryOperator<T> accumulator) {
return delegate.reduce(identity, accumulator);
}
public Optional<T> reduce(BinaryOperator<T> accumulator) {
return delegate.reduce(accumulator);
}
public <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner) {
return delegate.reduce(identity, accumulator, combiner);
}
public <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner) {
return delegate.collect(supplier, accumulator, combiner);
}
public <R, A> R collect(Collector<? super T, A, R> collector) {
return delegate.collect(collector);
}
public Optional<T> min(Comparator<? super T> comparator) {
return delegate.min(comparator);
}
public Optional<T> max(Comparator<? super T> comparator) {
return delegate.max(comparator);
}
public long count() {
return delegate.count();
}
public boolean anyMatch(Predicate<? super T> predicate) {
return delegate.anyMatch(predicate);
}
public boolean allMatch(Predicate<? super T> predicate) {
return delegate.allMatch(predicate);
}
public boolean noneMatch(Predicate<? super T> predicate) {
return delegate.noneMatch(predicate);
}
public Optional<T> findFirst() {
return delegate.findFirst();
}
public Optional<T> findAny() {
return delegate.findAny();
}
}

22
main/commons/src/main/java/org/cryptomator/common/streams/DelegatingStreamFactory.java
View File

@@ -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 {
<S> Stream<S> from(Stream<S> other);
IntStream from(IntStream other);
LongStream from(LongStream other);
DoubleStream from(DoubleStream other);
public interface ObjectStreamWrapper {
<S> Stream<S> from(Stream<S> other);
}
}

43
main/commons/src/test/java/org/cryptomator/common/CachingSupplierTest.java
View File

@@ -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<Object> delegate = mock(Supplier.class);
Object expectedResult = new Object();
when(delegate.get()).thenReturn(expectedResult);
Supplier<Object> inTest = CachingSupplier.from(delegate);
Object result = inTest.get();
assertThat(result, is(expectedResult));
}
@Test
public void testInvokingGetTwiceDoesNotInvokeDelegateTwice() {
@SuppressWarnings("unchecked")
Supplier<Object> delegate = mock(Supplier.class);
Object expectedResult = new Object();
when(delegate.get()).thenReturn(expectedResult);
Supplier<Object> inTest = CachingSupplier.from(delegate);
inTest.get();
Object result = inTest.get();
assertThat(result, is(expectedResult));
verify(delegate).get();
}
}

42
main/commons/src/test/java/org/cryptomator/common/HolderTest.java
View File

@@ -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<Object> 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));
}
}

156
main/commons/src/test/java/org/cryptomator/common/WeakValuedCacheTest.java
View File

@@ -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<String, Value> inTest;
private Function<String, Value> 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;
}
}
}

227
main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingDoubleStreamTest.java
View File

@@ -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<DoubleermediateOperation<?>> INTERMEDIATE_OPERATIONS = new ArrayList<>();
@DataPoints("terminalOperations")
public static final List<TerminalOperation<?>> 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 <T> void test(Consumer<DoubleStream> consumer) {
TERMINAL_OPERATIONS.add(new TerminalOperation<T>() {
@Override
public T result() {
return null;
}
@Override
public T apply(DoubleStream stream) {
consumer.accept(stream);
return null;
}
});
}
private static <T> void test(Function<DoubleStream, T> function, T result) {
TERMINAL_OPERATIONS.add(new TerminalOperation<T>() {
@Override
public T result() {
return result;
}
@Override
public T apply(DoubleStream stream) {
return function.apply(stream);
}
});
}
private static <T extends BaseStream> void test(Class<? extends T> type, Function<DoubleStream, T> function) {
INTERMEDIATE_OPERATIONS.add(new DoubleermediateOperation<T>() {
@Override
public Class<? extends T> 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<BaseStream> 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> {
T result();
T apply(DoubleStream stream);
}
private interface DoubleermediateOperation<T extends BaseStream> {
Class<? extends T> type();
T apply(DoubleStream stream);
}
}

228
main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingIntStreamTest.java
View File

@@ -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<IntermediateOperation<?>> INTERMEDIATE_OPERATIONS = new ArrayList<>();
@DataPoints("terminalOperations")
public static final List<TerminalOperation<?>> 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 <T> void test(Consumer<IntStream> consumer) {
TERMINAL_OPERATIONS.add(new TerminalOperation<T>() {
@Override
public T result() {
return null;
}
@Override
public T apply(IntStream stream) {
consumer.accept(stream);
return null;
}
});
}
private static <T> void test(Function<IntStream, T> function, T result) {
TERMINAL_OPERATIONS.add(new TerminalOperation<T>() {
@Override
public T result() {
return result;
}
@Override
public T apply(IntStream stream) {
return function.apply(stream);
}
});
}
private static <T extends BaseStream> void test(Class<? extends T> type, Function<IntStream, T> function) {
INTERMEDIATE_OPERATIONS.add(new IntermediateOperation<T>() {
@Override
public Class<? extends T> 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<BaseStream> 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> {
T result();
T apply(IntStream stream);
}
private interface IntermediateOperation<T extends BaseStream> {
Class<? extends T> type();
T apply(IntStream stream);
}
}

228
main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingLongStreamTest.java
View File

@@ -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<LongermediateOperation<?>> INTERMEDIATE_OPERATIONS = new ArrayList<>();
@DataPoints("terminalOperations")
public static final List<TerminalOperation<?>> 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 <T> void test(Consumer<LongStream> consumer) {
TERMINAL_OPERATIONS.add(new TerminalOperation<T>() {
@Override
public T result() {
return null;
}
@Override
public T apply(LongStream stream) {
consumer.accept(stream);
return null;
}
});
}
private static <T> void test(Function<LongStream, T> function, T result) {
TERMINAL_OPERATIONS.add(new TerminalOperation<T>() {
@Override
public T result() {
return result;
}
@Override
public T apply(LongStream stream) {
return function.apply(stream);
}
});
}
private static <T extends BaseStream> void test(Class<? extends T> type, Function<LongStream, T> function) {
INTERMEDIATE_OPERATIONS.add(new LongermediateOperation<T>() {
@Override
public Class<? extends T> 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<BaseStream> 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> {
T result();
T apply(LongStream stream);
}
private interface LongermediateOperation<T extends BaseStream> {
Class<? extends T> type();
T apply(LongStream stream);
}
}

231
main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingStreamTest.java
View File

@@ -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<IntermediateOperation<?>> INTERMEDIATE_OPERATIONS = new ArrayList<>();
@DataPoints("terminalOperations")
public static final List<TerminalOperation<?>> 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 <T> void test(Consumer<Stream> consumer) {
TERMINAL_OPERATIONS.add(new TerminalOperation<T>() {
@Override
public T result() {
return null;
}
@Override
public T apply(Stream stream) {
consumer.accept(stream);
return null;
}
});
}
private static <T> void test(Function<Stream, T> function, T result) {
TERMINAL_OPERATIONS.add(new TerminalOperation<T>() {
@Override
public T result() {
return result;
}
@Override
public T apply(Stream stream) {
return function.apply(stream);
}
});
}
private static <T extends BaseStream> void test(Class<? extends T> type, Function<Stream, T> function) {
INTERMEDIATE_OPERATIONS.add(new IntermediateOperation<T>() {
@Override
public Class<? extends T> type() {
return type;
}
@Override
public T apply(Stream stream) {
return function.apply(stream);
}
});
}
@Rule
public ExpectedException thrown = ExpectedException.none();
private Stream<Object> delegate;
private Stream<Object> 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<BaseStream> 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> {
T result();
T apply(Stream stream);
}
private interface IntermediateOperation<T extends BaseStream> {
Class<? extends T> type();
T apply(Stream stream);
}
}