Added project filesystem-invariants-tests

* Implemented some tests to be run on multiple implementations to
demonstrate how such tests can be implemented
* Detected problems with CryptoFileSystem(NioFileSystem)
* Made CryptoFileSystem and CryptorImpl public / constructible from
other packages

main/filesystem-invariants-tests/src/test/java/org/cryptomator/filesystem/invariants/FileSystemFactories.java

@@ -0,0 +1,78 @@
+package org.cryptomator.filesystem.invariants;
+
+import static java.nio.file.Files.createTempDirectory;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+
+import org.cryptomator.crypto.engine.impl.CryptorImpl;
+import org.cryptomator.filesystem.FileSystem;
+import org.cryptomator.filesystem.crypto.CryptoFileSystem;
+import org.cryptomator.filesystem.inmem.InMemoryFileSystem;
+import org.cryptomator.filesystem.nio.NioFileSystem;
+
+import com.google.common.base.Supplier;
+
+class FileSystemFactories implements Iterable<Supplier<FileSystem>> {
+
+	private static final SecureRandom RANDOM_MOCK = new SecureRandom() {
+		@Override
+		public void nextBytes(byte[] bytes) {
+			Arrays.fill(bytes, (byte) 0x00);
+		}
+	};
+
+	private final List<Supplier<FileSystem>> factories = new ArrayList<>();
+
+	public FileSystemFactories() {
+		add("NioFileSystem", this::createNioFileSystem);
+		add("InMemoryFileSystem", this::createInMemoryFileSystem);
+		add("CryptoFileSystem(InMemoryFileSystem)", this::createCryptoFileSystemInMemory);
+		// FIXME fails add("CryptoFileSystem(NioFileSystem)", this::createCryptoFileSystemNio);
+	}
+
+	private FileSystem createNioFileSystem() {
+		try {
+			return NioFileSystem.rootedAt(createTempDirectory("fileSystemToTest"));
+		} catch (IOException e) {
+			throw new UncheckedIOException(e);
+		}
+	}
+
+	private FileSystem createInMemoryFileSystem() {
+		return new InMemoryFileSystem();
+	}
+
+	private FileSystem createCryptoFileSystemInMemory() {
+		return new CryptoFileSystem(createInMemoryFileSystem(), new CryptorImpl(RANDOM_MOCK), "aPassphrase");
+	}
+
+	private FileSystem createCryptoFileSystemNio() {
+		return new CryptoFileSystem(createNioFileSystem(), new CryptorImpl(RANDOM_MOCK), "aPassphrase");
+	}
+
+	private void add(String name, Supplier<FileSystem> fileSystemSupplier) {
+		factories.add(new Supplier<FileSystem>() {
+			@Override
+			public FileSystem get() {
+				return fileSystemSupplier.get();
+			}
+
+			@Override
+			public String toString() {
+				return name;
+			}
+		});
+	}
+
+	@Override
+	public Iterator<Supplier<FileSystem>> iterator() {
+		return factories.iterator();
+	}
+
+}

main/filesystem-invariants-tests/src/test/java/org/cryptomator/filesystem/invariants/FileSystemTests.java

@@ -0,0 +1,91 @@
+package org.cryptomator.filesystem.invariants;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.Optional;
+
+import org.cryptomator.filesystem.FileSystem;
+import org.junit.Rule;
+import org.junit.experimental.theories.DataPoints;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+
+import com.google.common.base.Supplier;
+
+@RunWith(Theories.class)
+public class FileSystemTests {
+
+	@DataPoints
+	public static final Iterable<Supplier<FileSystem>> FILE_SYSTEM_FACTORIES = new FileSystemFactories();
+
+	@Rule
+	public final ExpectedException thrown = ExpectedException.none();
+
+	@Theory
+	public void testFileSystemHasNoParent(Supplier<FileSystem> factory) {
+		FileSystem inTest = factory.get();
+
+		assertThat(inTest.parent(), is(Optional.empty()));
+	}
+
+	@Theory
+	public void testFileSystemExists(Supplier<FileSystem> factory) {
+		FileSystem inTest = factory.get();
+
+		assertThat(inTest.exists(), is(true));
+	}
+
+	@Theory
+	public void testFileSystemHasNoChildren(Supplier<FileSystem> factory) {
+		FileSystem inTest = factory.get();
+
+		assertThat(inTest.children().count(), is(0L));
+	}
+
+	@Theory
+	public void testFileSystemHasNoFiles(Supplier<FileSystem> factory) {
+		FileSystem inTest = factory.get();
+
+		assertThat(inTest.files().count(), is(0L));
+	}
+
+	@Theory
+	public void testFileSystemHasNoFolders(Supplier<FileSystem> factory) {
+		FileSystem inTest = factory.get();
+
+		assertThat(inTest.folders().count(), is(0L));
+	}
+
+	@Theory
+	public void testFileSystemsFileSystemIsItself(Supplier<FileSystem> factory) {
+		FileSystem inTest = factory.get();
+
+		assertThat(inTest.fileSystem(), is(inTest));
+	}
+
+	@Theory
+	public void testFileSystemBelongsToSameFilesystemWhenCheckingItself(Supplier<FileSystem> factory) {
+		FileSystem inTest = factory.get();
+
+		assertThat(inTest.belongsToSameFilesystem(inTest), is(true));
+	}
+
+	@Theory
+	public void testFileSystemDoesNotBelongToSameFilesystemWhenCheckingOtherInstance(Supplier<FileSystem> factory) {
+		FileSystem inTest = factory.get();
+		FileSystem otherInstance = factory.get();
+
+		assertThat(inTest.belongsToSameFilesystem(otherInstance), is(false));
+	}
+
+	@Theory
+	public void testFileSystemIsNoAncestorOfItself(Supplier<FileSystem> factory) {
+		FileSystem inTest = factory.get();
+
+		assertThat(inTest.isAncestorOf(inTest), is(false));
+	}
+
+}