/*
* 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.jimfs.TestUtils.buffer;
import static com.google.common.jimfs.TestUtils.buffers;
import static com.google.common.jimfs.TestUtils.bytes;
import static com.google.common.primitives.Bytes.concat;
import static org.junit.Assert.assertArrayEquals;
import com.google.common.base.Predicate;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import java.io.IOException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.List;
import java.util.Random;
import java.util.Set;
/**
* Tests for {@link RegularFile} and by extension for {@link HeapDisk}. These tests test files
* created by a heap disk in a number of different states.
*
* @author Colin Decker
*/
public class RegularFileTest {
/**
* Returns a test suite for testing file methods with a variety of {@code HeapDisk}
* configurations.
*/
public static TestSuite suite() {
TestSuite suite = new TestSuite();
for (ReuseStrategy reuseStrategy : EnumSet.allOf(ReuseStrategy.class)) {
TestSuite suiteForReuseStrategy = new TestSuite(reuseStrategy.toString());
Set<List<Integer>> sizeOptions =
Sets.cartesianProduct(ImmutableList.of(BLOCK_SIZES, CACHE_SIZES));
for (List<Integer> options : sizeOptions) {
int blockSize = options.get(0);
int cacheSize = options.get(1);
if (cacheSize > 0 && cacheSize < blockSize) {
// skip cases where the cache size is not -1 (all) or 0 (none) but it is < blockSize,
// because this is equivalent to a cache size of 0
continue;
}
TestConfiguration state = new TestConfiguration(blockSize, cacheSize, reuseStrategy);
TestSuite suiteForTest = new TestSuite(state.toString());
for (Method method : TEST_METHODS) {
RegularFileTestRunner tester = new RegularFileTestRunner(method.getName(), state);
suiteForTest.addTest(tester);
}
suiteForReuseStrategy.addTest(suiteForTest);
}
suite.addTest(suiteForReuseStrategy);
}
return suite;
}
public static final ImmutableSet<Integer> BLOCK_SIZES = ImmutableSet.of(2, 8, 128, 8192);
public static final ImmutableSet<Integer> CACHE_SIZES = ImmutableSet.of(0, 4, 16, 128, -1);
private static final ImmutableList<Method> TEST_METHODS =
FluentIterable.from(Arrays.asList(RegularFileTestRunner.class.getDeclaredMethods()))
.filter(
new Predicate<Method>() {
@Override
public boolean apply(Method method) {
return method.getName().startsWith("test")
&& Modifier.isPublic(method.getModifiers())
&& method.getParameterTypes().length == 0;
}
})
.toList();
/**
* Different strategies for handling reuse of disks and/or files between tests, intended to
* ensure that {@link HeapDisk} operates properly in a variety of usage states including newly
* created, having created files that have not been deleted yet, having created files that have
* been deleted, and having created files some of which have been deleted and some of which have
* not.
*/
public enum ReuseStrategy {
/**
* Creates a new disk for each test.
*/
NEW_DISK,
/**
* Retains files after each test, forcing new blocks to be allocated.
*/
KEEP_FILES,
/**
* Deletes files after each test, allowing caching to be used if enabled.
*/
DELETE_FILES,
/**
* Randomly keeps or deletes a file after each test.
*/
KEEP_OR_DELETE_FILES
}
/**
* Configuration for a set of test cases.
*/
public static final class TestConfiguration {
private final int blockSize;
private final int cacheSize;
private final ReuseStrategy reuseStrategy;
private HeapDisk disk;
public TestConfiguration(int blockSize, int cacheSize, ReuseStrategy reuseStrategy) {
this.blockSize = blockSize;
this.cacheSize = cacheSize;
this.reuseStrategy = reuseStrategy;
if (reuseStrategy != ReuseStrategy.NEW_DISK) {
this.disk = createDisk();
}
}
private HeapDisk createDisk() {
int maxCachedBlockCount = cacheSize == -1 ? Integer.MAX_VALUE : (cacheSize / blockSize);
return new HeapDisk(blockSize, Integer.MAX_VALUE, maxCachedBlockCount);
}
public RegularFile createRegularFile() {
if (reuseStrategy == ReuseStrategy.NEW_DISK) {
disk = createDisk();
}
return RegularFile.create(0, disk);
}
public void tearDown(RegularFile file) {
switch (reuseStrategy) {
case DELETE_FILES:
file.deleted();
break;
case KEEP_OR_DELETE_FILES:
if (new Random().nextBoolean()) {
file.deleted();
}
break;
case KEEP_FILES:
break;
default:
break;
}
}
@Override
public String toString() {
return reuseStrategy + " [" + blockSize + ", " + cacheSize + "]";
}
}
/**
* Actual test cases for testing RegularFiles.
*/
public static class RegularFileTestRunner extends TestCase {
private final TestConfiguration configuration;
protected RegularFile file;
public RegularFileTestRunner(String methodName, TestConfiguration configuration) {
super(methodName);
this.configuration = configuration;
}
@Override
public String getName() {
return super.getName() + " [" + configuration + "]";
}
@Override
public void setUp() {
file = configuration.createRegularFile();
}
@Override
public void tearDown() {
configuration.tearDown(file);
}
private void fillContent(String fill) throws IOException {
file.write(0, buffer(fill));
}
public void testEmpty() {
assertEquals(0, file.size());
assertContentEquals("", file);
}
public void testEmpty_read_singleByte() {
assertEquals(-1, file.read(0));
assertEquals(-1, file.read(1));
}
public void testEmpty_read_byteArray() {
byte[] array = new byte[10];
assertEquals(-1, file.read(0, array, 0, array.length));
assertArrayEquals(bytes("0000000000"), array);
}
public void testEmpty_read_singleBuffer() {
ByteBuffer buffer = ByteBuffer.allocate(10);
int read = file.read(0, buffer);
assertEquals(-1, read);
assertEquals(0, buffer.position());
}
public void testEmpty_read_multipleBuffers() {
ByteBuffer buf1 = ByteBuffer.allocate(5);
ByteBuffer buf2 = ByteBuffer.allocate(5);
long read = file.read(0, ImmutableList.of(buf1, buf2));
assertEquals(-1, read);
assertEquals(0, buf1.position());
assertEquals(0, buf2.position());
}
public void testEmpty_write_singleByte_atStart() throws IOException {
file.write(0, (byte) 1);
assertContentEquals("1", file);
}
public void testEmpty_write_byteArray_atStart() throws IOException {
byte[] bytes = bytes("111111");
file.write(0, bytes, 0, bytes.length);
assertContentEquals(bytes, file);
}
public void testEmpty_write_partialByteArray_atStart() throws IOException {
byte[] bytes = bytes("2211111122");
file.write(0, bytes, 2, 6);
assertContentEquals("111111", file);
}
public void testEmpty_write_singleBuffer_atStart() throws IOException {
file.write(0, buffer("111111"));
assertContentEquals("111111", file);
}
public void testEmpty_write_multipleBuffers_atStart() throws IOException {
file.write(0, buffers("111", "111"));
assertContentEquals("111111", file);
}
public void testEmpty_write_singleByte_atNonZeroPosition() throws IOException {
file.write(5, (byte) 1);
assertContentEquals("000001", file);
}
public void testEmpty_write_byteArray_atNonZeroPosition() throws IOException {
byte[] bytes = bytes("111111");
file.write(5, bytes, 0, bytes.length);
assertContentEquals("00000111111", file);
}
public void testEmpty_write_partialByteArray_atNonZeroPosition() throws IOException {
byte[] bytes = bytes("2211111122");
file.write(5, bytes, 2, 6);
assertContentEquals("00000111111", file);
}
public void testEmpty_write_singleBuffer_atNonZeroPosition() throws IOException {
file.write(5, buffer("111"));
assertContentEquals("00000111", file);
}
public void testEmpty_write_multipleBuffers_atNonZeroPosition() throws IOException {
file.write(5, buffers("111", "222"));
assertContentEquals("00000111222", file);
}
public void testEmpty_write_noBytesArray_atStart() throws IOException {
file.write(0, bytes(), 0, 0);
assertContentEquals(bytes(), file);
}
public void testEmpty_write_noBytesArray_atNonZeroPosition() throws IOException {
file.write(5, bytes(), 0, 0);
assertContentEquals(bytes("00000"), file);
}
public void testEmpty_write_noBytesBuffer_atStart() throws IOException {
file.write(0, buffer(""));
assertContentEquals(bytes(), file);
}
public void testEmpty_write_noBytesBuffer_atNonZeroPosition() throws IOException {
ByteBuffer buffer = ByteBuffer.allocate(0);
file.write(5, buffer);
assertContentEquals(bytes("00000"), file);
}
public void testEmpty_write_noBytesBuffers_atStart() throws IOException {
file.write(0, ImmutableList.of(buffer(""), buffer(""), buffer("")));
assertContentEquals(bytes(), file);
}
public void testEmpty_write_noBytesBuffers_atNonZeroPosition() throws IOException {
file.write(5, ImmutableList.of(buffer(""), buffer(""), buffer("")));
assertContentEquals(bytes("00000"), file);
}
public void testEmpty_transferFrom_fromStart_countEqualsSrcSize() throws IOException {
long transferred = file.transferFrom(new ByteBufferChannel(buffer("111111")), 0, 6);
assertEquals(6, transferred);
assertContentEquals("111111", file);
}
public void testEmpty_transferFrom_fromStart_countLessThanSrcSize() throws IOException {
long transferred = file.transferFrom(new ByteBufferChannel(buffer("111111")), 0, 3);
assertEquals(3, transferred);
assertContentEquals("111", file);
}
public void testEmpty_transferFrom_fromStart_countGreaterThanSrcSize() throws IOException {
long transferred = file.transferFrom(new ByteBufferChannel(buffer("111111")), 0, 12);
assertEquals(6, transferred);
assertContentEquals("111111", file);
}
public void testEmpty_transferFrom_fromBeyondStart_countEqualsSrcSize() throws IOException {
long transferred = file.transferFrom(new ByteBufferChannel(buffer("111111")), 4, 6);
assertEquals(6, transferred);
assertContentEquals("0000111111", file);
}
public void testEmpty_transferFrom_fromBeyondStart_countLessThanSrcSize() throws IOException {
long transferred = file.transferFrom(new ByteBufferChannel(buffer("111111")), 4, 3);
assertEquals(3, transferred);
assertContentEquals("0000111", file);
}
public void testEmpty_transferFrom_fromBeyondStart_countGreaterThanSrcSize()
throws IOException {
long transferred = file.transferFrom(new ByteBufferChannel(buffer("111111")), 4, 12);
assertEquals(6, transferred);
assertContentEquals("0000111111", file);
}
public void testEmpty_transferFrom_fromStart_noBytes_countEqualsSrcSize() throws IOException {
long transferred = file.transferFrom(new ByteBufferChannel(buffer("")), 0, 0);
assertEquals(0, transferred);
assertContentEquals(bytes(), file);
}
public void testEmpty_transferFrom_fromStart_noBytes_countGreaterThanSrcSize()
throws IOException {
long transferred = file.transferFrom(new ByteBufferChannel(buffer("")), 0, 10);
assertEquals(0, transferred);
assertContentEquals(bytes(), file);
}
public void testEmpty_transferFrom_fromBeyondStart_noBytes_countEqualsSrcSize()
throws IOException {
long transferred = file.transferFrom(new ByteBufferChannel(buffer("")), 5, 0);
assertEquals(0, transferred);
assertContentEquals(bytes("00000"), file);
}
public void testEmpty_transferFrom_fromBeyondStart_noBytes_countGreaterThanSrcSize()
throws IOException {
long transferred = file.transferFrom(new ByteBufferChannel(buffer("")), 5, 10);
assertEquals(0, transferred);
assertContentEquals(bytes("00000"), file);
}
public void testEmpty_transferTo() throws IOException {
ByteBufferChannel channel = new ByteBufferChannel(100);
assertEquals(0, file.transferTo(0, 100, channel));
}
public void testEmpty_copy() throws IOException {
RegularFile copy = file.copyWithoutContent(1);
assertContentEquals("", copy);
}
public void testEmpty_truncate_toZero() throws IOException {
file.truncate(0);
assertContentEquals("", file);
}
public void testEmpty_truncate_sizeUp() throws IOException {
file.truncate(10);
assertContentEquals("", file);
}
public void testNonEmpty() throws IOException {
fillContent("222222");
assertContentEquals("222222", file);
}
public void testNonEmpty_read_singleByte() throws IOException {
fillContent("123456");
assertEquals(1, file.read(0));
assertEquals(2, file.read(1));
assertEquals(6, file.read(5));
assertEquals(-1, file.read(6));
assertEquals(-1, file.read(100));
}
public void testNonEmpty_read_all_byteArray() throws IOException {
fillContent("222222");
byte[] array = new byte[6];
assertEquals(6, file.read(0, array, 0, array.length));
assertArrayEquals(bytes("222222"), array);
}
public void testNonEmpty_read_all_singleBuffer() throws IOException {
fillContent("222222");
ByteBuffer buffer = ByteBuffer.allocate(6);
assertEquals(6, file.read(0, buffer));
assertBufferEquals("222222", 0, buffer);
}
public void testNonEmpty_read_all_multipleBuffers() throws IOException {
fillContent("223334");
ByteBuffer buf1 = ByteBuffer.allocate(3);
ByteBuffer buf2 = ByteBuffer.allocate(3);
assertEquals(6, file.read(0, ImmutableList.of(buf1, buf2)));
assertBufferEquals("223", 0, buf1);
assertBufferEquals("334", 0, buf2);
}
public void testNonEmpty_read_all_byteArray_largerThanContent() throws IOException {
fillContent("222222");
byte[] array = new byte[10];
assertEquals(6, file.read(0, array, 0, array.length));
assertArrayEquals(bytes("2222220000"), array);
array = new byte[10];
assertEquals(6, file.read(0, array, 2, 6));
assertArrayEquals(bytes("0022222200"), array);
}
public void testNonEmpty_read_all_singleBuffer_largerThanContent() throws IOException {
fillContent("222222");
ByteBuffer buffer = ByteBuffer.allocate(16);
assertBufferEquals("0000000000000000", 16, buffer);
assertEquals(6, file.read(0, buffer));
assertBufferEquals("2222220000000000", 10, buffer);
}
public void testNonEmpty_read_all_multipleBuffers_largerThanContent() throws IOException {
fillContent("222222");
ByteBuffer buf1 = ByteBuffer.allocate(4);
ByteBuffer buf2 = ByteBuffer.allocate(8);
assertEquals(6, file.read(0, ImmutableList.of(buf1, buf2)));
assertBufferEquals("2222", 0, buf1);
assertBufferEquals("22000000", 6, buf2);
}
public void testNonEmpty_read_all_multipleBuffers_extraBuffers() throws IOException {
fillContent("222222");
ByteBuffer buf1 = ByteBuffer.allocate(4);
ByteBuffer buf2 = ByteBuffer.allocate(8);
ByteBuffer buf3 = ByteBuffer.allocate(4);
assertEquals(6, file.read(0, ImmutableList.of(buf1, buf2, buf3)));
assertBufferEquals("2222", 0, buf1);
assertBufferEquals("22000000", 6, buf2);
assertBufferEquals("0000", 4, buf3);
}
public void testNonEmpty_read_partial_fromStart_byteArray() throws IOException {
fillContent("222222");
byte[] array = new byte[3];
assertEquals(3, file.read(0, array, 0, array.length));
assertArrayEquals(bytes("222"), array);
array = new byte[10];
assertEquals(3, file.read(0, array, 1, 3));
assertArrayEquals(bytes("0222000000"), array);
}
public void testNonEmpty_read_partial_fromMiddle_byteArray() throws IOException {
fillContent("22223333");
byte[] array = new byte[3];
assertEquals(3, file.read(3, array, 0, array.length));
assertArrayEquals(bytes("233"), array);
array = new byte[10];
assertEquals(3, file.read(3, array, 1, 3));
assertArrayEquals(bytes("0233000000"), array);
}
public void testNonEmpty_read_partial_fromEnd_byteArray() throws IOException {
fillContent("2222222222");
byte[] array = new byte[3];
assertEquals(2, file.read(8, array, 0, array.length));
assertArrayEquals(bytes("220"), array);
array = new byte[10];
assertEquals(2, file.read(8, array, 1, 3));
assertArrayEquals(bytes("0220000000"), array);
}
public void testNonEmpty_read_partial_fromStart_singleBuffer() throws IOException {
fillContent("222222");
ByteBuffer buffer = ByteBuffer.allocate(3);
assertEquals(3, file.read(0, buffer));
assertBufferEquals("222", 0, buffer);
}
public void testNonEmpty_read_partial_fromMiddle_singleBuffer() throws IOException {
fillContent("22223333");
ByteBuffer buffer = ByteBuffer.allocate(3);
assertEquals(3, file.read(3, buffer));
assertBufferEquals("233", 0, buffer);
}
public void testNonEmpty_read_partial_fromEnd_singleBuffer() throws IOException {
fillContent("2222222222");
ByteBuffer buffer = ByteBuffer.allocate(3);
assertEquals(2, file.read(8, buffer));
assertBufferEquals("220", 1, buffer);
}
public void testNonEmpty_read_partial_fromStart_multipleBuffers() throws IOException {
fillContent("12345678");
ByteBuffer buf1 = ByteBuffer.allocate(2);
ByteBuffer buf2 = ByteBuffer.allocate(2);
assertEquals(4, file.read(0, ImmutableList.of(buf1, buf2)));
assertBufferEquals("12", 0, buf1);
assertBufferEquals("34", 0, buf2);
}
public void testNonEmpty_read_partial_fromMiddle_multipleBuffers() throws IOException {
fillContent("12345678");
ByteBuffer buf1 = ByteBuffer.allocate(2);
ByteBuffer buf2 = ByteBuffer.allocate(2);
assertEquals(4, file.read(3, ImmutableList.of(buf1, buf2)));
assertBufferEquals("45", 0, buf1);
assertBufferEquals("67", 0, buf2);
}
public void testNonEmpty_read_partial_fromEnd_multipleBuffers() throws IOException {
fillContent("123456789");
ByteBuffer buf1 = ByteBuffer.allocate(2);
ByteBuffer buf2 = ByteBuffer.allocate(2);
assertEquals(3, file.read(6, ImmutableList.of(buf1, buf2)));
assertBufferEquals("78", 0, buf1);
assertBufferEquals("90", 1, buf2);
}
public void testNonEmpty_read_fromPastEnd_byteArray() throws IOException {
fillContent("123");
byte[] array = new byte[3];
assertEquals(-1, file.read(3, array, 0, array.length));
assertArrayEquals(bytes("000"), array);
assertEquals(-1, file.read(3, array, 0, 2));
assertArrayEquals(bytes("000"), array);
}
public void testNonEmpty_read_fromPastEnd_singleBuffer() throws IOException {
fillContent("123");
ByteBuffer buffer = ByteBuffer.allocate(3);
file.read(3, buffer);
assertBufferEquals("000", 3, buffer);
}
public void testNonEmpty_read_fromPastEnd_multipleBuffers() throws IOException {
fillContent("123");
ByteBuffer buf1 = ByteBuffer.allocate(2);
ByteBuffer buf2 = ByteBuffer.allocate(2);
assertEquals(-1, file.read(6, ImmutableList.of(buf1, buf2)));
assertBufferEquals("00", 2, buf1);
assertBufferEquals("00", 2, buf2);
}
public void testNonEmpty_write_partial_fromStart_singleByte() throws IOException {
fillContent("222222");
assertEquals(1, file.write(0, (byte) 1));
assertContentEquals("122222", file);
}
public void testNonEmpty_write_partial_fromMiddle_singleByte() throws IOException {
fillContent("222222");
assertEquals(1, file.write(3, (byte) 1));
assertContentEquals("222122", file);
}
public void testNonEmpty_write_partial_fromEnd_singleByte() throws IOException {
fillContent("222222");
assertEquals(1, file.write(6, (byte) 1));
assertContentEquals("2222221", file);
}
public void testNonEmpty_write_partial_fromStart_byteArray() throws IOException {
fillContent("222222");
assertEquals(3, file.write(0, bytes("111"), 0, 3));
assertContentEquals("111222", file);
assertEquals(2, file.write(0, bytes("333333"), 0, 2));
assertContentEquals("331222", file);
}
public void testNonEmpty_write_partial_fromMiddle_byteArray() throws IOException {
fillContent("22222222");
assertEquals(3, file.write(3, buffer("111")));
assertContentEquals("22211122", file);
assertEquals(2, file.write(5, bytes("333333"), 1, 2));
assertContentEquals("22211332", file);
}
public void testNonEmpty_write_partial_fromBeforeEnd_byteArray() throws IOException {
fillContent("22222222");
assertEquals(3, file.write(6, bytes("111"), 0, 3));
assertContentEquals("222222111", file);
assertEquals(2, file.write(8, bytes("333333"), 2, 2));
assertContentEquals("2222221133", file);
}
public void testNonEmpty_write_partial_fromEnd_byteArray() throws IOException {
fillContent("222222");
assertEquals(3, file.write(6, bytes("111"), 0, 3));
assertContentEquals("222222111", file);
assertEquals(2, file.write(9, bytes("333333"), 3, 2));
assertContentEquals("22222211133", file);
}
public void testNonEmpty_write_partial_fromPastEnd_byteArray() throws IOException {
fillContent("222222");
assertEquals(3, file.write(8, bytes("111"), 0, 3));
assertContentEquals("22222200111", file);
assertEquals(2, file.write(13, bytes("333333"), 4, 2));
assertContentEquals("222222001110033", file);
}
public void testNonEmpty_write_partial_fromStart_singleBuffer() throws IOException {
fillContent("222222");
assertEquals(3, file.write(0, buffer("111")));
assertContentEquals("111222", file);
}
public void testNonEmpty_write_partial_fromMiddle_singleBuffer() throws IOException {
fillContent("22222222");
assertEquals(3, file.write(3, buffer("111")));
assertContentEquals("22211122", file);
}
public void testNonEmpty_write_partial_fromBeforeEnd_singleBuffer() throws IOException {
fillContent("22222222");
assertEquals(3, file.write(6, buffer("111")));
assertContentEquals("222222111", file);
}
public void testNonEmpty_write_partial_fromEnd_singleBuffer() throws IOException {
fillContent("222222");
assertEquals(3, file.write(6, buffer("111")));
assertContentEquals("222222111", file);
}
public void testNonEmpty_write_partial_fromPastEnd_singleBuffer() throws IOException {
fillContent("222222");
assertEquals(3, file.write(8, buffer("111")));
assertContentEquals("22222200111", file);
}
public void testNonEmpty_write_partial_fromStart_multipleBuffers() throws IOException {
fillContent("222222");
assertEquals(4, file.write(0, buffers("11", "33")));
assertContentEquals("113322", file);
}
public void testNonEmpty_write_partial_fromMiddle_multipleBuffers() throws IOException {
fillContent("22222222");
assertEquals(4, file.write(2, buffers("11", "33")));
assertContentEquals("22113322", file);
}
public void testNonEmpty_write_partial_fromBeforeEnd_multipleBuffers() throws IOException {
fillContent("22222222");
assertEquals(6, file.write(6, buffers("111", "333")));
assertContentEquals("222222111333", file);
}
public void testNonEmpty_write_partial_fromEnd_multipleBuffers() throws IOException {
fillContent("222222");
assertEquals(6, file.write(6, buffers("111", "333")));
assertContentEquals("222222111333", file);
}
public void testNonEmpty_write_partial_fromPastEnd_multipleBuffers() throws IOException {
fillContent("222222");
assertEquals(4, file.write(10, buffers("11", "33")));
assertContentEquals("22222200001133", file);
}
public void testNonEmpty_write_overwrite_sameLength() throws IOException {
fillContent("2222");
assertEquals(4, file.write(0, buffer("1234")));
assertContentEquals("1234", file);
}
public void testNonEmpty_write_overwrite_greaterLength() throws IOException {
fillContent("2222");
assertEquals(8, file.write(0, buffer("12345678")));
assertContentEquals("12345678", file);
}
public void testNonEmpty_transferTo_fromStart_countEqualsSize() throws IOException {
fillContent("123456");
ByteBufferChannel channel = new ByteBufferChannel(10);
assertEquals(6, file.transferTo(0, 6, channel));
assertBufferEquals("1234560000", 4, channel.buffer());
}
public void testNonEmpty_transferTo_fromStart_countLessThanSize() throws IOException {
fillContent("123456");
ByteBufferChannel channel = new ByteBufferChannel(10);
assertEquals(4, file.transferTo(0, 4, channel));
assertBufferEquals("1234000000", 6, channel.buffer());
}
public void testNonEmpty_transferTo_fromMiddle_countEqualsSize() throws IOException {
fillContent("123456");
ByteBufferChannel channel = new ByteBufferChannel(10);
assertEquals(2, file.transferTo(4, 6, channel));
assertBufferEquals("5600000000", 8, channel.buffer());
}
public void testNonEmpty_transferTo_fromMiddle_countLessThanSize() throws IOException {
fillContent("12345678");
ByteBufferChannel channel = new ByteBufferChannel(10);
assertEquals(4, file.transferTo(3, 4, channel));
assertBufferEquals("4567000000", 6, channel.buffer());
}
public void testNonEmpty_transferFrom_toStart_countEqualsSrcSize() throws IOException {
fillContent("22222222");
ByteBufferChannel channel = new ByteBufferChannel(buffer("11111"));
assertEquals(5, file.transferFrom(channel, 0, 5));
assertContentEquals("11111222", file);
}
public void testNonEmpty_transferFrom_toStart_countLessThanSrcSize() throws IOException {
fillContent("22222222");
ByteBufferChannel channel = new ByteBufferChannel(buffer("11111"));
assertEquals(3, file.transferFrom(channel, 0, 3));
assertContentEquals("11122222", file);
}
public void testNonEmpty_transferFrom_toStart_countGreaterThanSrcSize() throws IOException {
fillContent("22222222");
ByteBufferChannel channel = new ByteBufferChannel(buffer("11111"));
assertEquals(5, file.transferFrom(channel, 0, 10));
assertContentEquals("11111222", file);
}
public void testNonEmpty_transferFrom_toMiddle_countEqualsSrcSize() throws IOException {
fillContent("22222222");
ByteBufferChannel channel = new ByteBufferChannel(buffer("1111"));
assertEquals(4, file.transferFrom(channel, 2, 4));
assertContentEquals("22111122", file);
}
public void testNonEmpty_transferFrom_toMiddle_countLessThanSrcSize() throws IOException {
fillContent("22222222");
ByteBufferChannel channel = new ByteBufferChannel(buffer("11111"));
assertEquals(3, file.transferFrom(channel, 2, 3));
assertContentEquals("22111222", file);
}
public void testNonEmpty_transferFrom_toMiddle_countGreaterThanSrcSize() throws IOException {
fillContent("22222222");
ByteBufferChannel channel = new ByteBufferChannel(buffer("1111"));
assertEquals(4, file.transferFrom(channel, 2, 100));
assertContentEquals("22111122", file);
}
public void testNonEmpty_transferFrom_toMiddle_transferGoesBeyondContentSize()
throws IOException {
fillContent("222222");
ByteBufferChannel channel = new ByteBufferChannel(buffer("111111"));
assertEquals(6, file.transferFrom(channel, 4, 6));
assertContentEquals("2222111111", file);
}
public void testNonEmpty_transferFrom_toEnd() throws IOException {
fillContent("222222");
ByteBufferChannel channel = new ByteBufferChannel(buffer("111111"));
assertEquals(6, file.transferFrom(channel, 6, 6));
assertContentEquals("222222111111", file);
}
public void testNonEmpty_transferFrom_toPastEnd() throws IOException {
fillContent("222222");
ByteBufferChannel channel = new ByteBufferChannel(buffer("111111"));
assertEquals(6, file.transferFrom(channel, 10, 6));
assertContentEquals("2222220000111111", file);
}
public void testNonEmpty_transferFrom_hugeOverestimateCount() throws IOException {
fillContent("222222");
ByteBufferChannel channel = new ByteBufferChannel(buffer("111111"));
assertEquals(6, file.transferFrom(channel, 6, 1024 * 1024 * 10));
assertContentEquals("222222111111", file);
}
public void testNonEmpty_copy() throws IOException {
fillContent("123456");
RegularFile copy = file.copyWithoutContent(1);
file.copyContentTo(copy);
assertContentEquals("123456", copy);
}
public void testNonEmpty_copy_multipleTimes() throws IOException {
fillContent("123456");
RegularFile copy = file.copyWithoutContent(1);
file.copyContentTo(copy);
RegularFile copy2 = copy.copyWithoutContent(2);
copy.copyContentTo(copy2);
assertContentEquals("123456", copy);
}
public void testNonEmpty_truncate_toZero() throws IOException {
fillContent("123456");
file.truncate(0);
assertContentEquals("", file);
}
public void testNonEmpty_truncate_partial() throws IOException {
fillContent("12345678");
file.truncate(5);
assertContentEquals("12345", file);
}
public void testNonEmpty_truncate_sizeUp() throws IOException {
fillContent("123456");
file.truncate(12);
assertContentEquals("123456", file);
}
public void testDeletedStoreRemainsUsableWhileOpen() throws IOException {
byte[] bytes = bytes("1234567890");
file.write(0, bytes, 0, bytes.length);
file.opened();
file.opened();
file.deleted();
assertContentEquals(bytes, file);
byte[] moreBytes = bytes("1234");
file.write(bytes.length, moreBytes, 0, 4);
byte[] totalBytes = concat(bytes, bytes("1234"));
assertContentEquals(totalBytes, file);
file.closed();
assertContentEquals(totalBytes, file);
file.closed();
// don't check anything else; no guarantee of what if anything will happen once the file is
// deleted and completely closed
}
private static void assertBufferEquals(String expected, ByteBuffer actual) {
assertEquals(expected.length(), actual.capacity());
assertArrayEquals(bytes(expected), actual.array());
}
private static void assertBufferEquals(String expected, int remaining, ByteBuffer actual) {
assertBufferEquals(expected, actual);
assertEquals(remaining, actual.remaining());
}
private static void assertContentEquals(String expected, RegularFile actual) {
assertContentEquals(bytes(expected), actual);
}
protected static void assertContentEquals(byte[] expected, RegularFile actual) {
assertEquals(expected.length, actual.sizeWithoutLocking());
byte[] actualBytes = new byte[(int) actual.sizeWithoutLocking()];
actual.read(0, ByteBuffer.wrap(actualBytes));
assertArrayEquals(expected, actualBytes);
}
}
}