diff options
Diffstat (limited to 'jimfs/src/test/java/com/google/common/jimfs/AttributeServiceTest.java')
-rw-r--r-- | jimfs/src/test/java/com/google/common/jimfs/AttributeServiceTest.java | 391 |
1 files changed, 391 insertions, 0 deletions
diff --git a/jimfs/src/test/java/com/google/common/jimfs/AttributeServiceTest.java b/jimfs/src/test/java/com/google/common/jimfs/AttributeServiceTest.java new file mode 100644 index 0000000..80b0191 --- /dev/null +++ b/jimfs/src/test/java/com/google/common/jimfs/AttributeServiceTest.java @@ -0,0 +1,391 @@ +/* + * Copyright 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.common.jimfs; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.fail; + +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import java.io.IOException; +import java.math.BigInteger; +import java.nio.file.attribute.BasicFileAttributeView; +import java.nio.file.attribute.BasicFileAttributes; +import java.nio.file.attribute.FileTime; +import java.nio.file.attribute.PosixFileAttributeView; +import java.nio.file.attribute.PosixFileAttributes; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +/** + * Tests for {@link AttributeService}. + * + * @author Colin Decker + */ +@RunWith(JUnit4.class) +public class AttributeServiceTest { + + private AttributeService service; + + @Before + public void setUp() { + ImmutableSet<AttributeProvider> providers = + ImmutableSet.of( + StandardAttributeProviders.get("basic"), + StandardAttributeProviders.get("owner"), + new TestAttributeProvider()); + service = new AttributeService(providers, ImmutableMap.<String, Object>of()); + } + + @Test + public void testSupportedFileAttributeViews() { + assertThat(service.supportedFileAttributeViews()) + .isEqualTo(ImmutableSet.of("basic", "test", "owner")); + } + + @Test + public void testSupportsFileAttributeView() { + assertThat(service.supportsFileAttributeView(BasicFileAttributeView.class)).isTrue(); + assertThat(service.supportsFileAttributeView(TestAttributeView.class)).isTrue(); + assertThat(service.supportsFileAttributeView(PosixFileAttributeView.class)).isFalse(); + } + + @Test + public void testSetInitialAttributes() { + File file = Directory.create(0); + service.setInitialAttributes(file); + + assertThat(file.getAttributeNames("test")).containsExactly("bar", "baz"); + assertThat(file.getAttributeNames("owner")).containsExactly("owner"); + + assertThat(service.getAttribute(file, "basic:lastModifiedTime")).isInstanceOf(FileTime.class); + assertThat(file.getAttribute("test", "bar")).isEqualTo(0L); + assertThat(file.getAttribute("test", "baz")).isEqualTo(1); + } + + @Test + public void testGetAttribute() { + File file = Directory.create(0); + service.setInitialAttributes(file); + + assertThat(service.getAttribute(file, "test:foo")).isEqualTo("hello"); + assertThat(service.getAttribute(file, "test", "foo")).isEqualTo("hello"); + assertThat(service.getAttribute(file, "basic:isRegularFile")).isEqualTo(false); + assertThat(service.getAttribute(file, "isDirectory")).isEqualTo(true); + assertThat(service.getAttribute(file, "test:baz")).isEqualTo(1); + } + + @Test + public void testGetAttribute_fromInheritedProvider() { + File file = Directory.create(0); + assertThat(service.getAttribute(file, "test:isRegularFile")).isEqualTo(false); + assertThat(service.getAttribute(file, "test:isDirectory")).isEqualTo(true); + assertThat(service.getAttribute(file, "test", "fileKey")).isEqualTo(0); + } + + @Test + public void testGetAttribute_failsForAttributesNotDefinedByProvider() { + File file = Directory.create(0); + try { + service.getAttribute(file, "test:blah"); + fail(); + } catch (IllegalArgumentException expected) { + } + + try { + // baz is defined by "test", but basic doesn't inherit test + service.getAttribute(file, "basic", "baz"); + fail(); + } catch (IllegalArgumentException expected) { + } + } + + @Test + public void testSetAttribute() { + File file = Directory.create(0); + service.setAttribute(file, "test:bar", 10L, false); + assertThat(file.getAttribute("test", "bar")).isEqualTo(10L); + + service.setAttribute(file, "test:baz", 100, false); + assertThat(file.getAttribute("test", "baz")).isEqualTo(100); + } + + @Test + public void testSetAttribute_forInheritedProvider() { + File file = Directory.create(0); + service.setAttribute(file, "test:lastModifiedTime", FileTime.fromMillis(0), false); + assertThat(file.getAttribute("test", "lastModifiedTime")).isNull(); + assertThat(service.getAttribute(file, "basic:lastModifiedTime")) + .isEqualTo(FileTime.fromMillis(0)); + } + + @Test + public void testSetAttribute_withAlternateAcceptedType() { + File file = Directory.create(0); + service.setAttribute(file, "test:bar", 10F, false); + assertThat(file.getAttribute("test", "bar")).isEqualTo(10L); + + service.setAttribute(file, "test:bar", BigInteger.valueOf(123), false); + assertThat(file.getAttribute("test", "bar")).isEqualTo(123L); + } + + @Test + public void testSetAttribute_onCreate() { + File file = Directory.create(0); + service.setInitialAttributes(file, new BasicFileAttribute<>("test:baz", 123)); + assertThat(file.getAttribute("test", "baz")).isEqualTo(123); + } + + @Test + public void testSetAttribute_failsForAttributesNotDefinedByProvider() { + File file = Directory.create(0); + service.setInitialAttributes(file); + + try { + service.setAttribute(file, "test:blah", "blah", false); + fail(); + } catch (UnsupportedOperationException expected) { + } + + try { + // baz is defined by "test", but basic doesn't inherit test + service.setAttribute(file, "basic:baz", 5, false); + fail(); + } catch (UnsupportedOperationException expected) { + } + + assertThat(file.getAttribute("test", "baz")).isEqualTo(1); + } + + @Test + public void testSetAttribute_failsForArgumentThatIsNotOfCorrectType() { + File file = Directory.create(0); + service.setInitialAttributes(file); + try { + service.setAttribute(file, "test:bar", "wrong", false); + fail(); + } catch (IllegalArgumentException expected) { + } + + assertThat(file.getAttribute("test", "bar")).isEqualTo(0L); + } + + @Test + public void testSetAttribute_failsForNullArgument() { + File file = Directory.create(0); + service.setInitialAttributes(file); + try { + service.setAttribute(file, "test:bar", null, false); + fail(); + } catch (NullPointerException expected) { + } + + assertThat(file.getAttribute("test", "bar")).isEqualTo(0L); + } + + @Test + public void testSetAttribute_failsForAttributeThatIsNotSettable() { + File file = Directory.create(0); + try { + service.setAttribute(file, "test:foo", "world", false); + fail(); + } catch (IllegalArgumentException expected) { + } + + assertThat(file.getAttribute("test", "foo")).isNull(); + } + + @Test + public void testSetAttribute_onCreate_failsForAttributeThatIsNotSettableOnCreate() { + File file = Directory.create(0); + try { + service.setInitialAttributes(file, new BasicFileAttribute<>("test:foo", "world")); + fail(); + } catch (UnsupportedOperationException expected) { + // it turns out that UOE should be thrown on create even if the attribute isn't settable + // under any circumstances + } + + try { + service.setInitialAttributes(file, new BasicFileAttribute<>("test:bar", 5)); + fail(); + } catch (UnsupportedOperationException expected) { + } + } + + @SuppressWarnings("ConstantConditions") + @Test + public void testGetFileAttributeView() throws IOException { + final File file = Directory.create(0); + service.setInitialAttributes(file); + + FileLookup fileLookup = + new FileLookup() { + @Override + public File lookup() throws IOException { + return file; + } + }; + + assertThat(service.getFileAttributeView(fileLookup, TestAttributeView.class)).isNotNull(); + assertThat(service.getFileAttributeView(fileLookup, BasicFileAttributeView.class)).isNotNull(); + + TestAttributes attrs = + service.getFileAttributeView(fileLookup, TestAttributeView.class).readAttributes(); + assertThat(attrs.foo()).isEqualTo("hello"); + assertThat(attrs.bar()).isEqualTo(0); + assertThat(attrs.baz()).isEqualTo(1); + } + + @Test + public void testGetFileAttributeView_isNullForUnsupportedView() { + final File file = Directory.create(0); + FileLookup fileLookup = + new FileLookup() { + @Override + public File lookup() throws IOException { + return file; + } + }; + assertThat(service.getFileAttributeView(fileLookup, PosixFileAttributeView.class)).isNull(); + } + + @Test + public void testReadAttributes_asMap() { + File file = Directory.create(0); + service.setInitialAttributes(file); + + ImmutableMap<String, Object> map = service.readAttributes(file, "test:foo,bar,baz"); + assertThat(map).isEqualTo(ImmutableMap.of("foo", "hello", "bar", 0L, "baz", 1)); + + FileTime time = (FileTime) service.getAttribute(file, "basic:creationTime"); + + map = service.readAttributes(file, "test:*"); + assertThat(map) + .isEqualTo( + ImmutableMap.<String, Object>builder() + .put("foo", "hello") + .put("bar", 0L) + .put("baz", 1) + .put("fileKey", 0) + .put("isDirectory", true) + .put("isRegularFile", false) + .put("isSymbolicLink", false) + .put("isOther", false) + .put("size", 0L) + .put("lastModifiedTime", time) + .put("lastAccessTime", time) + .put("creationTime", time) + .build()); + + map = service.readAttributes(file, "basic:*"); + assertThat(map) + .isEqualTo( + ImmutableMap.<String, Object>builder() + .put("fileKey", 0) + .put("isDirectory", true) + .put("isRegularFile", false) + .put("isSymbolicLink", false) + .put("isOther", false) + .put("size", 0L) + .put("lastModifiedTime", time) + .put("lastAccessTime", time) + .put("creationTime", time) + .build()); + } + + @Test + public void testReadAttributes_asMap_failsForInvalidAttributes() { + File file = Directory.create(0); + try { + service.readAttributes(file, "basic:fileKey,isOther,*,creationTime"); + fail(); + } catch (IllegalArgumentException expected) { + assertThat(expected.getMessage()).contains("invalid attributes"); + } + + try { + service.readAttributes(file, "basic:fileKey,isOther,foo"); + fail(); + } catch (IllegalArgumentException expected) { + assertThat(expected.getMessage()).contains("invalid attribute"); + } + } + + @Test + public void testReadAttributes_asObject() { + File file = Directory.create(0); + service.setInitialAttributes(file); + + BasicFileAttributes basicAttrs = service.readAttributes(file, BasicFileAttributes.class); + assertThat(basicAttrs.fileKey()).isEqualTo(0); + assertThat(basicAttrs.isDirectory()).isTrue(); + assertThat(basicAttrs.isRegularFile()).isFalse(); + + TestAttributes testAttrs = service.readAttributes(file, TestAttributes.class); + assertThat(testAttrs.foo()).isEqualTo("hello"); + assertThat(testAttrs.bar()).isEqualTo(0); + assertThat(testAttrs.baz()).isEqualTo(1); + + file.setAttribute("test", "baz", 100); + assertThat(service.readAttributes(file, TestAttributes.class).baz()).isEqualTo(100); + } + + @Test + public void testReadAttributes_failsForUnsupportedAttributesType() { + File file = Directory.create(0); + try { + service.readAttributes(file, PosixFileAttributes.class); + fail(); + } catch (UnsupportedOperationException expected) { + } + } + + @Test + public void testIllegalAttributeFormats() { + File file = Directory.create(0); + try { + service.getAttribute(file, ":bar"); + fail(); + } catch (IllegalArgumentException expected) { + assertThat(expected.getMessage()).contains("attribute format"); + } + + try { + service.getAttribute(file, "test:"); + fail(); + } catch (IllegalArgumentException expected) { + assertThat(expected.getMessage()).contains("attribute format"); + } + + try { + service.getAttribute(file, "basic:test:isDirectory"); + fail(); + } catch (IllegalArgumentException expected) { + assertThat(expected.getMessage()).contains("attribute format"); + } + + try { + service.getAttribute(file, "basic:fileKey,size"); + fail(); + } catch (IllegalArgumentException expected) { + assertThat(expected.getMessage()).contains("single attribute"); + } + } +} |