浏览代码

Removed unused classes

Sebastian Stenzel 8 年之前
父节点
当前提交
dbc803a0d9
共有 21 个文件被更改,包括 0 次插入2846 次删除
  1. 0 26
      main/commons/src/main/java/org/cryptomator/common/CachingSupplier.java
  2. 0 34
      main/commons/src/main/java/org/cryptomator/common/Holder.java
  3. 0 56
      main/commons/src/main/java/org/cryptomator/common/StackTrace.java
  4. 0 48
      main/commons/src/main/java/org/cryptomator/common/WeakValuedCache.java
  5. 0 178
      main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingDoubleStream.java
  6. 0 179
      main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingIntStream.java
  7. 0 179
      main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingLongStream.java
  8. 0 173
      main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingStream.java
  9. 0 51
      main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingStreamFactory.java
  10. 0 179
      main/commons/src/main/java/org/cryptomator/common/streams/DelegatingDoubleStream.java
  11. 0 188
      main/commons/src/main/java/org/cryptomator/common/streams/DelegatingIntStream.java
  12. 0 184
      main/commons/src/main/java/org/cryptomator/common/streams/DelegatingLongStream.java
  13. 0 194
      main/commons/src/main/java/org/cryptomator/common/streams/DelegatingStream.java
  14. 0 22
      main/commons/src/main/java/org/cryptomator/common/streams/DelegatingStreamFactory.java
  15. 0 43
      main/commons/src/test/java/org/cryptomator/common/CachingSupplierTest.java
  16. 0 42
      main/commons/src/test/java/org/cryptomator/common/HolderTest.java
  17. 0 156
      main/commons/src/test/java/org/cryptomator/common/WeakValuedCacheTest.java
  18. 0 227
      main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingDoubleStreamTest.java
  19. 0 228
      main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingIntStreamTest.java
  20. 0 228
      main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingLongStreamTest.java
  21. 0 231
      main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingStreamTest.java

+ 0 - 26
main/commons/src/main/java/org/cryptomator/common/CachingSupplier.java

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

+ 0 - 34
main/commons/src/main/java/org/cryptomator/common/Holder.java

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

+ 0 - 56
main/commons/src/main/java/org/cryptomator/common/StackTrace.java

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

+ 0 - 48
main/commons/src/main/java/org/cryptomator/common/WeakValuedCache.java

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

+ 0 - 178
main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingDoubleStream.java

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

+ 0 - 179
main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingIntStream.java

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

+ 0 - 179
main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingLongStream.java

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

+ 0 - 173
main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingStream.java

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

+ 0 - 51
main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingStreamFactory.java

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

+ 0 - 179
main/commons/src/main/java/org/cryptomator/common/streams/DelegatingDoubleStream.java

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

+ 0 - 188
main/commons/src/main/java/org/cryptomator/common/streams/DelegatingIntStream.java

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

+ 0 - 184
main/commons/src/main/java/org/cryptomator/common/streams/DelegatingLongStream.java

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

+ 0 - 194
main/commons/src/main/java/org/cryptomator/common/streams/DelegatingStream.java

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

+ 0 - 22
main/commons/src/main/java/org/cryptomator/common/streams/DelegatingStreamFactory.java

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

+ 0 - 43
main/commons/src/test/java/org/cryptomator/common/CachingSupplierTest.java

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

+ 0 - 42
main/commons/src/test/java/org/cryptomator/common/HolderTest.java

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

+ 0 - 156
main/commons/src/test/java/org/cryptomator/common/WeakValuedCacheTest.java

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

+ 0 - 227
main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingDoubleStreamTest.java

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

+ 0 - 228
main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingIntStreamTest.java

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

+ 0 - 228
main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingLongStreamTest.java

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

+ 0 - 231
main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingStreamTest.java

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