restored DelegatingReadableFile and DelegatingWritableFile for I/O stats

main/filesystem-api/src/main/java/org/cryptomator/filesystem/delegating/DelegatingReadableFile.java

@@ -0,0 +1,49 @@
+/*******************************************************************************
+ * Copyright (c) 2015 Sebastian Stenzel and others.
+ * This file is licensed under the terms of the MIT license.
+ * See the LICENSE.txt file for more info.
+ *
+ * Contributors:
+ *     Sebastian Stenzel - initial API and implementation
+ *******************************************************************************/
+package org.cryptomator.filesystem.delegating;
+
+import java.io.UncheckedIOException;
+import java.nio.ByteBuffer;
+
+import org.cryptomator.filesystem.ReadableFile;
+
+public class DelegatingReadableFile implements ReadableFile {
+
+	private final ReadableFile delegate;
+
+	public DelegatingReadableFile(ReadableFile delegate) {
+		this.delegate = delegate;
+	}
+
+	@Override
+	public boolean isOpen() {
+		return delegate.isOpen();
+	}
+
+	@Override
+	public int read(ByteBuffer target) throws UncheckedIOException {
+		return delegate.read(target);
+	}
+
+	@Override
+	public long size() throws UncheckedIOException {
+		return delegate.size();
+	}
+
+	@Override
+	public void position(long position) throws UncheckedIOException {
+		delegate.position(position);
+	}
+
+	@Override
+	public void close() throws UncheckedIOException {
+		delegate.close();
+	}
+
+}

main/filesystem-api/src/main/java/org/cryptomator/filesystem/delegating/DelegatingWritableFile.java

@@ -0,0 +1,75 @@
+/*******************************************************************************
+ * Copyright (c) 2015 Sebastian Stenzel and others.
+ * This file is licensed under the terms of the MIT license.
+ * See the LICENSE.txt file for more info.
+ *
+ * Contributors:
+ *     Sebastian Stenzel - initial API and implementation
+ *******************************************************************************/
+package org.cryptomator.filesystem.delegating;
+
+import java.io.UncheckedIOException;
+import java.nio.ByteBuffer;
+import java.time.Instant;
+
+import org.cryptomator.filesystem.WritableFile;
+
+public class DelegatingWritableFile implements WritableFile {
+
+	final WritableFile delegate;
+
+	public DelegatingWritableFile(WritableFile delegate) {
+		this.delegate = delegate;
+	}
+
+	@Override
+	public boolean isOpen() {
+		return delegate.isOpen();
+	}
+
+	@Override
+	public void moveTo(WritableFile destination) throws UncheckedIOException {
+		if (getClass().equals(destination.getClass())) {
+			final WritableFile delegateDest = ((DelegatingWritableFile) destination).delegate;
+			delegate.moveTo(delegateDest);
+		} else {
+			throw new IllegalArgumentException("Can only move DelegatingWritableFile to a DelegatingWritableFile.");
+		}
+	}
+
+	@Override
+	public void setLastModified(Instant instant) throws UncheckedIOException {
+		delegate.setLastModified(instant);
+	}
+
+	@Override
+	public void delete() throws UncheckedIOException {
+		delegate.delete();
+	}
+
+	@Override
+	public void truncate() throws UncheckedIOException {
+		delegate.truncate();
+	}
+
+	@Override
+	public int write(ByteBuffer source) throws UncheckedIOException {
+		return delegate.write(source);
+	}
+
+	@Override
+	public void position(long position) throws UncheckedIOException {
+		delegate.position(position);
+	}
+
+	@Override
+	public void close() throws UncheckedIOException {
+		delegate.close();
+	}
+
+	@Override
+	public void setCreationTime(Instant instant) throws UncheckedIOException {
+		delegate.setCreationTime(instant);
+	}
+
+}

main/filesystem-api/src/test/java/org/cryptomator/filesystem/delegating/DelegatingFolderTest.java

@@ -174,4 +174,15 @@ public class DelegatingFolderTest {
 		Assert.assertSame(delegatingFolder.file("mockSubFile"), delegatingFolder.file("mockSubFile"));
 	}
 
+	@Test
+	public void testSetCreationTime() {
+		Folder mockFolder = Mockito.mock(Folder.class);
+		DelegatingFolder<?, ?> delegatingFolder = new TestDelegatingFolder(null, mockFolder);
+
+		Instant now = Instant.now();
+
+		delegatingFolder.setCreationTime(now);
+		Mockito.verify(mockFolder).setCreationTime(now);
+	}
+
 }

main/filesystem-api/src/test/java/org/cryptomator/filesystem/delegating/DelegatingReadableFileTest.java

@@ -0,0 +1,75 @@
+/*******************************************************************************
+ * Copyright (c) 2015 Sebastian Stenzel and others.
+ * This file is licensed under the terms of the MIT license.
+ * See the LICENSE.txt file for more info.
+ *
+ * Contributors:
+ *     Sebastian Stenzel - initial API and implementation
+ *******************************************************************************/
+package org.cryptomator.filesystem.delegating;
+
+import java.nio.ByteBuffer;
+
+import org.cryptomator.filesystem.ReadableFile;
+import org.junit.Assert;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+public class DelegatingReadableFileTest {
+
+	@Test
+	public void testIsOpen() {
+		ReadableFile mockReadableFile = Mockito.mock(ReadableFile.class);
+		@SuppressWarnings("resource")
+		DelegatingReadableFile delegatingReadableFile = new DelegatingReadableFile(mockReadableFile);
+
+		Mockito.when(mockReadableFile.isOpen()).thenReturn(true);
+		Assert.assertTrue(delegatingReadableFile.isOpen());
+
+		Mockito.when(mockReadableFile.isOpen()).thenReturn(false);
+		Assert.assertFalse(delegatingReadableFile.isOpen());
+	}
+
+	@Test
+	public void testRead() {
+		ReadableFile mockReadableFile = Mockito.mock(ReadableFile.class);
+		@SuppressWarnings("resource")
+		DelegatingReadableFile delegatingReadableFile = new DelegatingReadableFile(mockReadableFile);
+
+		ByteBuffer buf = ByteBuffer.allocate(4);
+		Mockito.when(mockReadableFile.read(buf)).thenReturn(4);
+		Assert.assertEquals(4, delegatingReadableFile.read(buf));
+		Mockito.verify(mockReadableFile).read(buf);
+	}
+
+	@Test
+	public void testSize() {
+		ReadableFile mockReadableFile = Mockito.mock(ReadableFile.class);
+		@SuppressWarnings("resource")
+		DelegatingReadableFile delegatingReadableFile = new DelegatingReadableFile(mockReadableFile);
+
+		Mockito.when(mockReadableFile.size()).thenReturn(42l);
+		Assert.assertEquals(42l, delegatingReadableFile.size());
+		Mockito.verify(mockReadableFile).size();
+	}
+
+	@Test
+	public void testPosition() {
+		ReadableFile mockReadableFile = Mockito.mock(ReadableFile.class);
+		@SuppressWarnings("resource")
+		DelegatingReadableFile delegatingReadableFile = new DelegatingReadableFile(mockReadableFile);
+
+		delegatingReadableFile.position(42);
+		Mockito.verify(mockReadableFile).position(42);
+	}
+
+	@Test
+	public void testClose() {
+		ReadableFile mockReadableFile = Mockito.mock(ReadableFile.class);
+		DelegatingReadableFile delegatingReadableFile = new DelegatingReadableFile(mockReadableFile);
+
+		delegatingReadableFile.close();
+		Mockito.verify(mockReadableFile).close();
+	}
+
+}

main/filesystem-api/src/test/java/org/cryptomator/filesystem/delegating/DelegatingWritableFileTest.java

@@ -0,0 +1,130 @@
+/*******************************************************************************
+ * Copyright (c) 2015 Sebastian Stenzel and others.
+ * This file is licensed under the terms of the MIT license.
+ * See the LICENSE.txt file for more info.
+ *
+ * Contributors:
+ *     Sebastian Stenzel - initial API and implementation
+ *******************************************************************************/
+package org.cryptomator.filesystem.delegating;
+
+import java.nio.ByteBuffer;
+import java.time.Instant;
+
+import org.cryptomator.filesystem.WritableFile;
+import org.junit.Assert;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+public class DelegatingWritableFileTest {
+
+	@Test
+	public void testIsOpen() {
+		WritableFile mockWritableFile = Mockito.mock(WritableFile.class);
+		@SuppressWarnings("resource")
+		DelegatingWritableFile delegatingWritableFile = new DelegatingWritableFile(mockWritableFile);
+
+		Mockito.when(mockWritableFile.isOpen()).thenReturn(true);
+		Assert.assertTrue(delegatingWritableFile.isOpen());
+
+		Mockito.when(mockWritableFile.isOpen()).thenReturn(false);
+		Assert.assertFalse(delegatingWritableFile.isOpen());
+	}
+
+	@Test
+	public void testMoveTo() {
+		WritableFile mockWritableFile1 = Mockito.mock(WritableFile.class);
+		WritableFile mockWritableFile2 = Mockito.mock(WritableFile.class);
+		@SuppressWarnings("resource")
+		DelegatingWritableFile delegatingWritableFile1 = new DelegatingWritableFile(mockWritableFile1);
+		DelegatingWritableFile delegatingWritableFile2 = new DelegatingWritableFile(mockWritableFile2);
+
+		delegatingWritableFile1.moveTo(delegatingWritableFile2);
+		Mockito.verify(mockWritableFile1).moveTo(mockWritableFile2);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void testMoveToDestinationFromDifferentLayer() {
+		WritableFile mockWritableFile1 = Mockito.mock(WritableFile.class);
+		WritableFile mockWritableFile2 = Mockito.mock(WritableFile.class);
+		@SuppressWarnings("resource")
+		DelegatingWritableFile delegatingWritableFile1 = new DelegatingWritableFile(mockWritableFile1);
+
+		delegatingWritableFile1.moveTo(mockWritableFile2);
+	}
+
+	@Test
+	public void testSetLastModified() {
+		WritableFile mockWritableFile = Mockito.mock(WritableFile.class);
+		@SuppressWarnings("resource")
+		DelegatingWritableFile delegatingWritableFile = new DelegatingWritableFile(mockWritableFile);
+
+		Instant now = Instant.now();
+		delegatingWritableFile.setLastModified(now);
+		Mockito.verify(mockWritableFile).setLastModified(now);
+	}
+
+	@Test
+	public void testDelete() {
+		WritableFile mockWritableFile = Mockito.mock(WritableFile.class);
+		@SuppressWarnings("resource")
+		DelegatingWritableFile delegatingWritableFile = new DelegatingWritableFile(mockWritableFile);
+
+		delegatingWritableFile.delete();
+		Mockito.verify(mockWritableFile).delete();
+	}
+
+	@Test
+	public void testTruncate() {
+		WritableFile mockWritableFile = Mockito.mock(WritableFile.class);
+		@SuppressWarnings("resource")
+		DelegatingWritableFile delegatingWritableFile = new DelegatingWritableFile(mockWritableFile);
+
+		delegatingWritableFile.truncate();
+		Mockito.verify(mockWritableFile).truncate();
+	}
+
+	@Test
+	public void testWrite() {
+		WritableFile mockWritableFile = Mockito.mock(WritableFile.class);
+		@SuppressWarnings("resource")
+		DelegatingWritableFile delegatingWritableFile = new DelegatingWritableFile(mockWritableFile);
+
+		ByteBuffer buf = ByteBuffer.allocate(4);
+		Mockito.when(mockWritableFile.write(buf)).thenReturn(4);
+		Assert.assertEquals(4, delegatingWritableFile.write(buf));
+		Mockito.verify(mockWritableFile).write(buf);
+	}
+
+	@Test
+	public void testPosition() {
+		WritableFile mockWritableFile = Mockito.mock(WritableFile.class);
+		@SuppressWarnings("resource")
+		DelegatingWritableFile delegatingWritableFile = new DelegatingWritableFile(mockWritableFile);
+
+		delegatingWritableFile.position(42);
+		Mockito.verify(mockWritableFile).position(42);
+	}
+
+	@Test
+	public void testClose() {
+		WritableFile mockWritableFile = Mockito.mock(WritableFile.class);
+		DelegatingWritableFile delegatingWritableFile = new DelegatingWritableFile(mockWritableFile);
+
+		delegatingWritableFile.close();
+		Mockito.verify(mockWritableFile).close();
+	}
+
+	@Test
+	public void testSetCreationTime() {
+		WritableFile mockWritableFile = Mockito.mock(WritableFile.class);
+		@SuppressWarnings("resource")
+		DelegatingWritableFile delegatingWritableFile = new DelegatingWritableFile(mockWritableFile);
+
+		Instant now = Instant.now();
+
+		delegatingWritableFile.setCreationTime(now);
+		Mockito.verify(mockWritableFile).setCreationTime(now);
+	}
+
+}