/*
* 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 org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
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;
/**
* 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 (IllegalArgumentException expected) {
}
try {
// baz is defined by "test", but basic doesn't inherit test
service.setAttribute(file, "basic:baz", 5, false);
fail();
} catch (IllegalArgumentException 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 (IllegalArgumentException expected) {
// IAE because test:foo just can't be set
}
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()).is(0);
assertThat(attrs.baz()).is(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()).is(0);
assertThat(testAttrs.baz()).is(1);
file.setAttribute("test", "baz", 100);
assertThat(service.readAttributes(file, TestAttributes.class).baz()).is(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");
}
}
}