731 lines
23 KiB
Java
731 lines
23 KiB
Java
/*
|
|
* Copyright (C) 2007 The Guava Authors
|
|
*
|
|
* 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.io;
|
|
|
|
import static com.google.common.truth.Truth.assertThat;
|
|
|
|
import com.google.common.base.Charsets;
|
|
import com.google.common.collect.ImmutableList;
|
|
import com.google.common.hash.Hashing;
|
|
import com.google.common.primitives.Bytes;
|
|
import java.io.BufferedReader;
|
|
import java.io.BufferedWriter;
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.File;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.IOException;
|
|
import java.io.PrintWriter;
|
|
import java.io.RandomAccessFile;
|
|
import java.nio.ByteBuffer;
|
|
import java.nio.MappedByteBuffer;
|
|
import java.nio.channels.FileChannel.MapMode;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.List;
|
|
import java.util.Random;
|
|
import junit.framework.TestSuite;
|
|
|
|
/**
|
|
* Unit test for {@link Files}.
|
|
*
|
|
* <p>Note: {@link Files#fileTraverser()} is tested in {@link FilesFileTraverserTest}.
|
|
*
|
|
* @author Chris Nokleberg
|
|
*/
|
|
|
|
public class FilesTest extends IoTestCase {
|
|
|
|
public static TestSuite suite() {
|
|
TestSuite suite = new TestSuite();
|
|
suite.addTest(
|
|
ByteSourceTester.tests(
|
|
"Files.asByteSource[File]", SourceSinkFactories.fileByteSourceFactory(), true));
|
|
suite.addTest(
|
|
ByteSinkTester.tests("Files.asByteSink[File]", SourceSinkFactories.fileByteSinkFactory()));
|
|
suite.addTest(
|
|
ByteSinkTester.tests(
|
|
"Files.asByteSink[File, APPEND]", SourceSinkFactories.appendingFileByteSinkFactory()));
|
|
suite.addTest(
|
|
CharSourceTester.tests(
|
|
"Files.asCharSource[File, Charset]",
|
|
SourceSinkFactories.fileCharSourceFactory(),
|
|
false));
|
|
suite.addTest(
|
|
CharSinkTester.tests(
|
|
"Files.asCharSink[File, Charset]", SourceSinkFactories.fileCharSinkFactory()));
|
|
suite.addTest(
|
|
CharSinkTester.tests(
|
|
"Files.asCharSink[File, Charset, APPEND]",
|
|
SourceSinkFactories.appendingFileCharSinkFactory()));
|
|
suite.addTestSuite(FilesTest.class);
|
|
return suite;
|
|
}
|
|
|
|
public void testRoundTripSources() throws Exception {
|
|
File asciiFile = getTestFile("ascii.txt");
|
|
ByteSource byteSource = Files.asByteSource(asciiFile);
|
|
assertSame(byteSource, byteSource.asCharSource(Charsets.UTF_8).asByteSource(Charsets.UTF_8));
|
|
}
|
|
|
|
public void testToByteArray() throws IOException {
|
|
File asciiFile = getTestFile("ascii.txt");
|
|
File i18nFile = getTestFile("i18n.txt");
|
|
assertTrue(Arrays.equals(ASCII.getBytes(Charsets.US_ASCII), Files.toByteArray(asciiFile)));
|
|
assertTrue(Arrays.equals(I18N.getBytes(Charsets.UTF_8), Files.toByteArray(i18nFile)));
|
|
assertTrue(Arrays.equals(I18N.getBytes(Charsets.UTF_8), Files.asByteSource(i18nFile).read()));
|
|
}
|
|
|
|
/** A {@link File} that provides a specialized value for {@link File#length()}. */
|
|
private static class BadLengthFile extends File {
|
|
|
|
private final long badLength;
|
|
|
|
public BadLengthFile(File delegate, long badLength) {
|
|
super(delegate.getPath());
|
|
this.badLength = badLength;
|
|
}
|
|
|
|
@Override
|
|
public long length() {
|
|
return badLength;
|
|
}
|
|
|
|
private static final long serialVersionUID = 0;
|
|
}
|
|
|
|
public void testToString() throws IOException {
|
|
File asciiFile = getTestFile("ascii.txt");
|
|
File i18nFile = getTestFile("i18n.txt");
|
|
assertEquals(ASCII, Files.toString(asciiFile, Charsets.US_ASCII));
|
|
assertEquals(I18N, Files.toString(i18nFile, Charsets.UTF_8));
|
|
assertThat(Files.toString(i18nFile, Charsets.US_ASCII)).isNotEqualTo(I18N);
|
|
}
|
|
|
|
public void testWriteString() throws IOException {
|
|
File temp = createTempFile();
|
|
Files.write(I18N, temp, Charsets.UTF_16LE);
|
|
assertEquals(I18N, Files.toString(temp, Charsets.UTF_16LE));
|
|
}
|
|
|
|
public void testWriteBytes() throws IOException {
|
|
File temp = createTempFile();
|
|
byte[] data = newPreFilledByteArray(2000);
|
|
Files.write(data, temp);
|
|
assertTrue(Arrays.equals(data, Files.toByteArray(temp)));
|
|
|
|
try {
|
|
Files.write(null, temp);
|
|
fail("expected exception");
|
|
} catch (NullPointerException expected) {
|
|
}
|
|
}
|
|
|
|
public void testAppendString() throws IOException {
|
|
File temp = createTempFile();
|
|
Files.append(I18N, temp, Charsets.UTF_16LE);
|
|
assertEquals(I18N, Files.toString(temp, Charsets.UTF_16LE));
|
|
Files.append(I18N, temp, Charsets.UTF_16LE);
|
|
assertEquals(I18N + I18N, Files.toString(temp, Charsets.UTF_16LE));
|
|
Files.append(I18N, temp, Charsets.UTF_16LE);
|
|
assertEquals(I18N + I18N + I18N, Files.toString(temp, Charsets.UTF_16LE));
|
|
}
|
|
|
|
public void testCopyToOutputStream() throws IOException {
|
|
File i18nFile = getTestFile("i18n.txt");
|
|
ByteArrayOutputStream out = new ByteArrayOutputStream();
|
|
Files.copy(i18nFile, out);
|
|
assertEquals(I18N, out.toString("UTF-8"));
|
|
}
|
|
|
|
public void testCopyToAppendable() throws IOException {
|
|
File i18nFile = getTestFile("i18n.txt");
|
|
StringBuilder sb = new StringBuilder();
|
|
Files.copy(i18nFile, Charsets.UTF_8, sb);
|
|
assertEquals(I18N, sb.toString());
|
|
}
|
|
|
|
public void testCopyFile() throws IOException {
|
|
File i18nFile = getTestFile("i18n.txt");
|
|
File temp = createTempFile();
|
|
Files.copy(i18nFile, temp);
|
|
assertEquals(I18N, Files.toString(temp, Charsets.UTF_8));
|
|
}
|
|
|
|
public void testCopyEqualFiles() throws IOException {
|
|
File temp1 = createTempFile();
|
|
File temp2 = file(temp1.getPath());
|
|
assertEquals(temp1, temp2);
|
|
Files.write(ASCII, temp1, Charsets.UTF_8);
|
|
try {
|
|
Files.copy(temp1, temp2);
|
|
fail("Expected an IAE to be thrown but wasn't");
|
|
} catch (IllegalArgumentException expected) {
|
|
}
|
|
assertEquals(ASCII, Files.toString(temp1, Charsets.UTF_8));
|
|
}
|
|
|
|
public void testCopySameFile() throws IOException {
|
|
File temp = createTempFile();
|
|
Files.write(ASCII, temp, Charsets.UTF_8);
|
|
try {
|
|
Files.copy(temp, temp);
|
|
fail("Expected an IAE to be thrown but wasn't");
|
|
} catch (IllegalArgumentException expected) {
|
|
}
|
|
assertEquals(ASCII, Files.toString(temp, Charsets.UTF_8));
|
|
}
|
|
|
|
public void testCopyIdenticalFiles() throws IOException {
|
|
File temp1 = createTempFile();
|
|
Files.write(ASCII, temp1, Charsets.UTF_8);
|
|
File temp2 = createTempFile();
|
|
Files.write(ASCII, temp2, Charsets.UTF_8);
|
|
Files.copy(temp1, temp2);
|
|
assertEquals(ASCII, Files.toString(temp2, Charsets.UTF_8));
|
|
}
|
|
|
|
public void testEqual() throws IOException {
|
|
File asciiFile = getTestFile("ascii.txt");
|
|
File i18nFile = getTestFile("i18n.txt");
|
|
assertFalse(Files.equal(asciiFile, i18nFile));
|
|
assertTrue(Files.equal(asciiFile, asciiFile));
|
|
|
|
File temp = createTempFile();
|
|
Files.copy(asciiFile, temp);
|
|
assertTrue(Files.equal(asciiFile, temp));
|
|
|
|
Files.copy(i18nFile, temp);
|
|
assertTrue(Files.equal(i18nFile, temp));
|
|
|
|
Files.copy(asciiFile, temp);
|
|
RandomAccessFile rf = new RandomAccessFile(temp, "rw");
|
|
rf.writeByte(0);
|
|
rf.close();
|
|
assertEquals(asciiFile.length(), temp.length());
|
|
assertFalse(Files.equal(asciiFile, temp));
|
|
|
|
assertTrue(Files.asByteSource(asciiFile).contentEquals(Files.asByteSource(asciiFile)));
|
|
|
|
// 0-length files have special treatment (/proc, etc.)
|
|
assertTrue(Files.equal(asciiFile, new BadLengthFile(asciiFile, 0)));
|
|
}
|
|
|
|
public void testNewReader() throws IOException {
|
|
File asciiFile = getTestFile("ascii.txt");
|
|
try {
|
|
Files.newReader(asciiFile, null);
|
|
fail("expected exception");
|
|
} catch (NullPointerException expected) {
|
|
}
|
|
|
|
try {
|
|
Files.newReader(null, Charsets.UTF_8);
|
|
fail("expected exception");
|
|
} catch (NullPointerException expected) {
|
|
}
|
|
|
|
BufferedReader r = Files.newReader(asciiFile, Charsets.US_ASCII);
|
|
try {
|
|
assertEquals(ASCII, r.readLine());
|
|
} finally {
|
|
r.close();
|
|
}
|
|
}
|
|
|
|
public void testNewWriter() throws IOException {
|
|
File temp = createTempFile();
|
|
try {
|
|
Files.newWriter(temp, null);
|
|
fail("expected exception");
|
|
} catch (NullPointerException expected) {
|
|
}
|
|
|
|
try {
|
|
Files.newWriter(null, Charsets.UTF_8);
|
|
fail("expected exception");
|
|
} catch (NullPointerException expected) {
|
|
}
|
|
|
|
BufferedWriter w = Files.newWriter(temp, Charsets.UTF_8);
|
|
try {
|
|
w.write(I18N);
|
|
} finally {
|
|
w.close();
|
|
}
|
|
|
|
File i18nFile = getTestFile("i18n.txt");
|
|
assertTrue(Files.equal(i18nFile, temp));
|
|
}
|
|
|
|
public void testTouch() throws IOException {
|
|
File temp = createTempFile();
|
|
assertTrue(temp.exists());
|
|
assertTrue(temp.delete());
|
|
assertFalse(temp.exists());
|
|
Files.touch(temp);
|
|
assertTrue(temp.exists());
|
|
Files.touch(temp);
|
|
assertTrue(temp.exists());
|
|
|
|
try {
|
|
Files.touch(
|
|
new File(temp.getPath()) {
|
|
@Override
|
|
public boolean setLastModified(long t) {
|
|
return false;
|
|
}
|
|
|
|
private static final long serialVersionUID = 0;
|
|
});
|
|
fail("expected exception");
|
|
} catch (IOException expected) {
|
|
}
|
|
}
|
|
|
|
public void testTouchTime() throws IOException {
|
|
File temp = createTempFile();
|
|
assertTrue(temp.exists());
|
|
temp.setLastModified(0);
|
|
assertEquals(0, temp.lastModified());
|
|
Files.touch(temp);
|
|
assertThat(temp.lastModified()).isNotEqualTo(0);
|
|
}
|
|
|
|
public void testCreateParentDirs_root() throws IOException {
|
|
File file = root();
|
|
assertNull(file.getParentFile());
|
|
assertNull(file.getCanonicalFile().getParentFile());
|
|
Files.createParentDirs(file);
|
|
}
|
|
|
|
public void testCreateParentDirs_relativePath() throws IOException {
|
|
File file = file("nonexistent.file");
|
|
assertNull(file.getParentFile());
|
|
assertNotNull(file.getCanonicalFile().getParentFile());
|
|
Files.createParentDirs(file);
|
|
}
|
|
|
|
public void testCreateParentDirs_noParentsNeeded() throws IOException {
|
|
File file = file(getTempDir(), "nonexistent.file");
|
|
assertTrue(file.getParentFile().exists());
|
|
Files.createParentDirs(file);
|
|
}
|
|
|
|
public void testCreateParentDirs_oneParentNeeded() throws IOException {
|
|
File file = file(getTempDir(), "parent", "nonexistent.file");
|
|
File parent = file.getParentFile();
|
|
assertFalse(parent.exists());
|
|
try {
|
|
Files.createParentDirs(file);
|
|
assertTrue(parent.exists());
|
|
} finally {
|
|
assertTrue(parent.delete());
|
|
}
|
|
}
|
|
|
|
public void testCreateParentDirs_multipleParentsNeeded() throws IOException {
|
|
File file = file(getTempDir(), "grandparent", "parent", "nonexistent.file");
|
|
File parent = file.getParentFile();
|
|
File grandparent = parent.getParentFile();
|
|
assertFalse(grandparent.exists());
|
|
Files.createParentDirs(file);
|
|
assertTrue(parent.exists());
|
|
}
|
|
|
|
public void testCreateParentDirs_nonDirectoryParentExists() throws IOException {
|
|
File parent = getTestFile("ascii.txt");
|
|
assertTrue(parent.isFile());
|
|
File file = file(parent, "foo");
|
|
try {
|
|
Files.createParentDirs(file);
|
|
fail();
|
|
} catch (IOException expected) {
|
|
}
|
|
}
|
|
|
|
public void testCreateTempDir() {
|
|
File temp = Files.createTempDir();
|
|
assertTrue(temp.exists());
|
|
assertTrue(temp.isDirectory());
|
|
assertThat(temp.listFiles()).isEmpty();
|
|
assertTrue(temp.delete());
|
|
}
|
|
|
|
public void testMove() throws IOException {
|
|
File i18nFile = getTestFile("i18n.txt");
|
|
File temp1 = createTempFile();
|
|
File temp2 = createTempFile();
|
|
|
|
Files.copy(i18nFile, temp1);
|
|
moveHelper(true, temp1, temp2);
|
|
assertTrue(Files.equal(temp2, i18nFile));
|
|
}
|
|
|
|
public void testMoveViaCopy() throws IOException {
|
|
File i18nFile = getTestFile("i18n.txt");
|
|
File temp1 = createTempFile();
|
|
File temp2 = createTempFile();
|
|
|
|
Files.copy(i18nFile, temp1);
|
|
moveHelper(true, new UnmovableFile(temp1, false, true), temp2);
|
|
assertTrue(Files.equal(temp2, i18nFile));
|
|
}
|
|
|
|
public void testMoveFailures() throws IOException {
|
|
File temp1 = createTempFile();
|
|
File temp2 = createTempFile();
|
|
|
|
moveHelper(false, new UnmovableFile(temp1, false, false), temp2);
|
|
moveHelper(
|
|
false, new UnmovableFile(temp1, false, false), new UnmovableFile(temp2, true, false));
|
|
|
|
try {
|
|
File asciiFile = getTestFile("ascii.txt");
|
|
moveHelper(false, asciiFile, asciiFile);
|
|
fail("expected exception");
|
|
} catch (IllegalArgumentException expected) {
|
|
}
|
|
}
|
|
|
|
private void moveHelper(boolean success, File from, File to) throws IOException {
|
|
try {
|
|
Files.move(from, to);
|
|
if (success) {
|
|
assertFalse(from.exists());
|
|
assertTrue(to.exists());
|
|
} else {
|
|
fail("expected exception");
|
|
}
|
|
} catch (IOException possiblyExpected) {
|
|
if (success) {
|
|
throw possiblyExpected;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static class UnmovableFile extends File {
|
|
|
|
private final boolean canRename;
|
|
private final boolean canDelete;
|
|
|
|
public UnmovableFile(File file, boolean canRename, boolean canDelete) {
|
|
super(file.getPath());
|
|
this.canRename = canRename;
|
|
this.canDelete = canDelete;
|
|
}
|
|
|
|
@Override
|
|
public boolean renameTo(File to) {
|
|
return canRename && super.renameTo(to);
|
|
}
|
|
|
|
@Override
|
|
public boolean delete() {
|
|
return canDelete && super.delete();
|
|
}
|
|
|
|
private static final long serialVersionUID = 0;
|
|
}
|
|
|
|
public void testLineReading() throws IOException {
|
|
File temp = createTempFile();
|
|
assertNull(Files.readFirstLine(temp, Charsets.UTF_8));
|
|
assertTrue(Files.readLines(temp, Charsets.UTF_8).isEmpty());
|
|
|
|
PrintWriter w = new PrintWriter(Files.newWriter(temp, Charsets.UTF_8));
|
|
w.println("hello");
|
|
w.println("");
|
|
w.println(" world ");
|
|
w.println("");
|
|
w.close();
|
|
|
|
assertEquals("hello", Files.readFirstLine(temp, Charsets.UTF_8));
|
|
assertEquals(
|
|
ImmutableList.of("hello", "", " world ", ""), Files.readLines(temp, Charsets.UTF_8));
|
|
|
|
assertTrue(temp.delete());
|
|
}
|
|
|
|
public void testReadLines_withLineProcessor() throws IOException {
|
|
File temp = createTempFile();
|
|
LineProcessor<List<String>> collect =
|
|
new LineProcessor<List<String>>() {
|
|
List<String> collector = new ArrayList<>();
|
|
|
|
@Override
|
|
public boolean processLine(String line) {
|
|
collector.add(line);
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public List<String> getResult() {
|
|
return collector;
|
|
}
|
|
};
|
|
assertThat(Files.readLines(temp, Charsets.UTF_8, collect)).isEmpty();
|
|
|
|
PrintWriter w = new PrintWriter(Files.newWriter(temp, Charsets.UTF_8));
|
|
w.println("hello");
|
|
w.println("");
|
|
w.println(" world ");
|
|
w.println("");
|
|
w.close();
|
|
Files.readLines(temp, Charsets.UTF_8, collect);
|
|
assertThat(collect.getResult()).containsExactly("hello", "", " world ", "").inOrder();
|
|
|
|
LineProcessor<List<String>> collectNonEmptyLines =
|
|
new LineProcessor<List<String>>() {
|
|
List<String> collector = new ArrayList<>();
|
|
|
|
@Override
|
|
public boolean processLine(String line) {
|
|
if (line.length() > 0) {
|
|
collector.add(line);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public List<String> getResult() {
|
|
return collector;
|
|
}
|
|
};
|
|
Files.readLines(temp, Charsets.UTF_8, collectNonEmptyLines);
|
|
assertThat(collectNonEmptyLines.getResult()).containsExactly("hello", " world ").inOrder();
|
|
|
|
assertTrue(temp.delete());
|
|
}
|
|
|
|
public void testHash() throws IOException {
|
|
File asciiFile = getTestFile("ascii.txt");
|
|
File i18nFile = getTestFile("i18n.txt");
|
|
|
|
String init = "d41d8cd98f00b204e9800998ecf8427e";
|
|
assertEquals(init, Hashing.md5().newHasher().hash().toString());
|
|
|
|
String asciiHash = "e5df5a39f2b8cb71b24e1d8038f93131";
|
|
assertEquals(asciiHash, Files.hash(asciiFile, Hashing.md5()).toString());
|
|
|
|
String i18nHash = "7fa826962ce2079c8334cd4ebf33aea4";
|
|
assertEquals(i18nHash, Files.hash(i18nFile, Hashing.md5()).toString());
|
|
}
|
|
|
|
public void testMap() throws IOException {
|
|
// Test data
|
|
int size = 1024;
|
|
byte[] bytes = newPreFilledByteArray(size);
|
|
|
|
// Setup
|
|
File file = createTempFile();
|
|
Files.write(bytes, file);
|
|
|
|
// Test
|
|
MappedByteBuffer actual = Files.map(file);
|
|
|
|
// Verify
|
|
ByteBuffer expected = ByteBuffer.wrap(bytes);
|
|
assertTrue("ByteBuffers should be equal.", expected.equals(actual));
|
|
}
|
|
|
|
public void testMap_noSuchFile() throws IOException {
|
|
// Setup
|
|
File file = createTempFile();
|
|
boolean deleted = file.delete();
|
|
assertTrue(deleted);
|
|
|
|
// Test
|
|
try {
|
|
Files.map(file);
|
|
fail("Should have thrown FileNotFoundException.");
|
|
} catch (FileNotFoundException expected) {
|
|
}
|
|
}
|
|
|
|
public void testMap_readWrite() throws IOException {
|
|
// Test data
|
|
int size = 1024;
|
|
byte[] expectedBytes = new byte[size];
|
|
byte[] bytes = newPreFilledByteArray(1024);
|
|
|
|
// Setup
|
|
File file = createTempFile();
|
|
Files.write(bytes, file);
|
|
|
|
Random random = new Random();
|
|
random.nextBytes(expectedBytes);
|
|
|
|
// Test
|
|
MappedByteBuffer map = Files.map(file, MapMode.READ_WRITE);
|
|
map.put(expectedBytes);
|
|
|
|
// Verify
|
|
byte[] actualBytes = Files.toByteArray(file);
|
|
assertTrue(Arrays.equals(expectedBytes, actualBytes));
|
|
}
|
|
|
|
public void testMap_readWrite_creates() throws IOException {
|
|
// Test data
|
|
int size = 1024;
|
|
byte[] expectedBytes = newPreFilledByteArray(1024);
|
|
|
|
// Setup
|
|
File file = createTempFile();
|
|
boolean deleted = file.delete();
|
|
assertTrue(deleted);
|
|
assertFalse(file.exists());
|
|
|
|
// Test
|
|
MappedByteBuffer map = Files.map(file, MapMode.READ_WRITE, size);
|
|
map.put(expectedBytes);
|
|
|
|
// Verify
|
|
assertTrue(file.exists());
|
|
assertTrue(file.isFile());
|
|
assertEquals(size, file.length());
|
|
byte[] actualBytes = Files.toByteArray(file);
|
|
assertTrue(Arrays.equals(expectedBytes, actualBytes));
|
|
}
|
|
|
|
public void testMap_readWrite_max_value_plus_1() throws IOException {
|
|
// Setup
|
|
File file = createTempFile();
|
|
// Test
|
|
try {
|
|
Files.map(file, MapMode.READ_WRITE, (long) Integer.MAX_VALUE + 1);
|
|
fail("Should throw when size exceeds Integer.MAX_VALUE");
|
|
} catch (IllegalArgumentException expected) {
|
|
}
|
|
}
|
|
|
|
public void testGetFileExtension() {
|
|
assertEquals("txt", Files.getFileExtension(".txt"));
|
|
assertEquals("txt", Files.getFileExtension("blah.txt"));
|
|
assertEquals("txt", Files.getFileExtension("blah..txt"));
|
|
assertEquals("txt", Files.getFileExtension(".blah.txt"));
|
|
assertEquals("txt", Files.getFileExtension("/tmp/blah.txt"));
|
|
assertEquals("gz", Files.getFileExtension("blah.tar.gz"));
|
|
assertEquals("", Files.getFileExtension("/"));
|
|
assertEquals("", Files.getFileExtension("."));
|
|
assertEquals("", Files.getFileExtension(".."));
|
|
assertEquals("", Files.getFileExtension("..."));
|
|
assertEquals("", Files.getFileExtension("blah"));
|
|
assertEquals("", Files.getFileExtension("blah."));
|
|
assertEquals("", Files.getFileExtension(".blah."));
|
|
assertEquals("", Files.getFileExtension("/foo.bar/blah"));
|
|
assertEquals("", Files.getFileExtension("/foo/.bar/blah"));
|
|
}
|
|
|
|
public void testGetNameWithoutExtension() {
|
|
assertEquals("", Files.getNameWithoutExtension(".txt"));
|
|
assertEquals("blah", Files.getNameWithoutExtension("blah.txt"));
|
|
assertEquals("blah.", Files.getNameWithoutExtension("blah..txt"));
|
|
assertEquals(".blah", Files.getNameWithoutExtension(".blah.txt"));
|
|
assertEquals("blah", Files.getNameWithoutExtension("/tmp/blah.txt"));
|
|
assertEquals("blah.tar", Files.getNameWithoutExtension("blah.tar.gz"));
|
|
assertEquals("", Files.getNameWithoutExtension("/"));
|
|
assertEquals("", Files.getNameWithoutExtension("."));
|
|
assertEquals(".", Files.getNameWithoutExtension(".."));
|
|
assertEquals("..", Files.getNameWithoutExtension("..."));
|
|
assertEquals("blah", Files.getNameWithoutExtension("blah"));
|
|
assertEquals("blah", Files.getNameWithoutExtension("blah."));
|
|
assertEquals(".blah", Files.getNameWithoutExtension(".blah."));
|
|
assertEquals("blah", Files.getNameWithoutExtension("/foo.bar/blah"));
|
|
assertEquals("blah", Files.getNameWithoutExtension("/foo/.bar/blah"));
|
|
}
|
|
|
|
public void testReadBytes() throws IOException {
|
|
ByteProcessor<byte[]> processor =
|
|
new ByteProcessor<byte[]>() {
|
|
private final ByteArrayOutputStream out = new ByteArrayOutputStream();
|
|
|
|
@Override
|
|
public boolean processBytes(byte[] buffer, int offset, int length) throws IOException {
|
|
if (length >= 0) {
|
|
out.write(buffer, offset, length);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public byte[] getResult() {
|
|
return out.toByteArray();
|
|
}
|
|
};
|
|
|
|
File asciiFile = getTestFile("ascii.txt");
|
|
byte[] result = Files.readBytes(asciiFile, processor);
|
|
assertEquals(Bytes.asList(Files.toByteArray(asciiFile)), Bytes.asList(result));
|
|
}
|
|
|
|
public void testReadBytes_returnFalse() throws IOException {
|
|
ByteProcessor<byte[]> processor =
|
|
new ByteProcessor<byte[]>() {
|
|
private final ByteArrayOutputStream out = new ByteArrayOutputStream();
|
|
|
|
@Override
|
|
public boolean processBytes(byte[] buffer, int offset, int length) throws IOException {
|
|
if (length > 0) {
|
|
out.write(buffer, offset, 1);
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public byte[] getResult() {
|
|
return out.toByteArray();
|
|
}
|
|
};
|
|
|
|
File asciiFile = getTestFile("ascii.txt");
|
|
byte[] result = Files.readBytes(asciiFile, processor);
|
|
assertEquals(1, result.length);
|
|
}
|
|
|
|
public void testPredicates() throws IOException {
|
|
File asciiFile = getTestFile("ascii.txt");
|
|
File dir = asciiFile.getParentFile();
|
|
assertTrue(Files.isDirectory().apply(dir));
|
|
assertFalse(Files.isFile().apply(dir));
|
|
|
|
assertFalse(Files.isDirectory().apply(asciiFile));
|
|
assertTrue(Files.isFile().apply(asciiFile));
|
|
}
|
|
|
|
/** Returns a root path for the file system. */
|
|
private static File root() {
|
|
return File.listRoots()[0];
|
|
}
|
|
|
|
/** Returns a {@code File} object for the given path parts. */
|
|
private static File file(String first, String... more) {
|
|
return file(new File(first), more);
|
|
}
|
|
|
|
/** Returns a {@code File} object for the given path parts. */
|
|
private static File file(File first, String... more) {
|
|
// not very efficient, but should definitely be correct
|
|
File file = first;
|
|
for (String name : more) {
|
|
file = new File(file, name);
|
|
}
|
|
return file;
|
|
}
|
|
}
|