From 4059f99fd5aa3b49aac6a4c588b96294a25a0665 Mon Sep 17 00:00:00 2001 From: Sebastian Stenzel Date: Thu, 28 Jan 2016 20:33:16 +0100 Subject: [PATCH] restored DelegatingReadableFile and DelegatingWritableFile for I/O stats --- .../delegating/DelegatingReadableFile.java | 49 +++++++ .../delegating/DelegatingWritableFile.java | 75 ++++++++++ .../delegating/DelegatingFolderTest.java | 11 ++ .../DelegatingReadableFileTest.java | 75 ++++++++++ .../DelegatingWritableFileTest.java | 130 ++++++++++++++++++ 5 files changed, 340 insertions(+) create mode 100644 main/filesystem-api/src/main/java/org/cryptomator/filesystem/delegating/DelegatingReadableFile.java create mode 100644 main/filesystem-api/src/main/java/org/cryptomator/filesystem/delegating/DelegatingWritableFile.java create mode 100644 main/filesystem-api/src/test/java/org/cryptomator/filesystem/delegating/DelegatingReadableFileTest.java create mode 100644 main/filesystem-api/src/test/java/org/cryptomator/filesystem/delegating/DelegatingWritableFileTest.java diff --git a/main/filesystem-api/src/main/java/org/cryptomator/filesystem/delegating/DelegatingReadableFile.java b/main/filesystem-api/src/main/java/org/cryptomator/filesystem/delegating/DelegatingReadableFile.java new file mode 100644 index 000000000..435601782 --- /dev/null +++ b/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(); + } + +} diff --git a/main/filesystem-api/src/main/java/org/cryptomator/filesystem/delegating/DelegatingWritableFile.java b/main/filesystem-api/src/main/java/org/cryptomator/filesystem/delegating/DelegatingWritableFile.java new file mode 100644 index 000000000..66bd05712 --- /dev/null +++ b/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); + } + +} diff --git a/main/filesystem-api/src/test/java/org/cryptomator/filesystem/delegating/DelegatingFolderTest.java b/main/filesystem-api/src/test/java/org/cryptomator/filesystem/delegating/DelegatingFolderTest.java index 9763e0225..09345464a 100644 --- a/main/filesystem-api/src/test/java/org/cryptomator/filesystem/delegating/DelegatingFolderTest.java +++ b/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); + } + } diff --git a/main/filesystem-api/src/test/java/org/cryptomator/filesystem/delegating/DelegatingReadableFileTest.java b/main/filesystem-api/src/test/java/org/cryptomator/filesystem/delegating/DelegatingReadableFileTest.java new file mode 100644 index 000000000..0777bd5da --- /dev/null +++ b/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(); + } + +} diff --git a/main/filesystem-api/src/test/java/org/cryptomator/filesystem/delegating/DelegatingWritableFileTest.java b/main/filesystem-api/src/test/java/org/cryptomator/filesystem/delegating/DelegatingWritableFileTest.java new file mode 100644 index 000000000..856049d75 --- /dev/null +++ b/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); + } + +}