private void insertData(ByteBufferDirectory dir, int bufferSizeInBytes) throws IOException {
byte[] test = new byte[] {1, 2, 3, 4, 5, 6, 7, 8};
IndexOutput indexOutput = dir.createOutput("value1", IOContext.DEFAULT);
indexOutput.writeBytes(new byte[] {2, 4, 6, 7, 8}, 5);
indexOutput.writeInt(-1);
indexOutput.writeLong(10);
indexOutput.writeInt(0);
indexOutput.writeInt(0);
indexOutput.writeBytes(test, 8);
indexOutput.writeBytes(test, 5);
indexOutput.seek(0);
indexOutput.writeByte((byte) 8);
if (bufferSizeInBytes > 4) {
indexOutput.seek(2);
indexOutput.writeBytes(new byte[] {1, 2}, 2);
}
indexOutput.close();
}
private void insertData(CoherenceDirectory dir, String fileName) throws IOException {
byte[] test = new byte[] {1, 2, 3, 4, 5, 6, 7, 8};
IndexOutput indexOutput = dir.createOutput(fileName);
indexOutput.writeBytes(new byte[] {2, 4, 6, 7, 8}, 5);
indexOutput.writeInt(-1);
indexOutput.writeLong(10);
indexOutput.writeInt(0);
indexOutput.writeInt(0);
indexOutput.writeBytes(test, 8);
indexOutput.writeBytes(test, 5);
indexOutput.seek(0);
indexOutput.writeByte((byte) 8);
if (dir.getBucketSize() > 4) {
indexOutput.seek(2);
indexOutput.writeBytes(new byte[] {1, 2}, 2);
}
indexOutput.close();
}
public void testWriteChunks() throws Exception {
final int BUFFER_SIZE = 64;
Cache cache = cacheManager.getCache();
Directory dir =
DirectoryBuilder.newDirectoryInstance(cache, cache, cache, INDEXNAME)
.chunkSize(BUFFER_SIZE)
.create();
IndexOutput io = dir.createOutput("MyNewFile.txt");
io.writeByte((byte) 66);
io.writeByte((byte) 69);
io.flush();
io.close();
assert dir.fileExists("MyNewFile.txt");
assert null != cache.get(new ChunkCacheKey(INDEXNAME, "MyNewFile.txt", 0, BUFFER_SIZE));
// test contents by reading:
byte[] buf = new byte[9];
IndexInput ii = dir.openInput("MyNewFile.txt");
ii.readBytes(buf, 0, (int) ii.length());
ii.close();
assert new String(new byte[] {66, 69}).equals(new String(buf).trim());
String testText =
"This is some rubbish again that will span more than one chunk - one hopes. Who knows, maybe even three or four chunks.";
io = dir.createOutput("MyNewFile.txt");
io.seek(0);
io.writeBytes(testText.getBytes(), 0, testText.length());
io.close();
// now compare.
byte[] chunk1 =
(byte[]) cache.get(new ChunkCacheKey(INDEXNAME, "MyNewFile.txt", 0, BUFFER_SIZE));
byte[] chunk2 =
(byte[]) cache.get(new ChunkCacheKey(INDEXNAME, "MyNewFile.txt", 1, BUFFER_SIZE));
assert null != chunk1;
assert null != chunk2;
assert testText.equals(new String(chunk1) + new String(chunk2).trim());
dir.close();
DirectoryIntegrityCheck.verifyDirectoryStructure(cache, INDEXNAME);
}
@Override
public void seek(long pos) throws IOException {
delegate.seek(pos);
}
protected void writeTrailer(long dirStart) throws IOException {
out.seek(CodecUtil.headerLength(CODEC_NAME));
out.writeLong(dirStart);
}
@Test
public void testWriteUsingSeekMethod() throws IOException {
final int BUFFER_SIZE = 64;
Cache cache = cacheManager.getCache();
Directory dir =
DirectoryBuilder.newDirectoryInstance(cache, cache, cache, INDEXNAME)
.chunkSize(BUFFER_SIZE)
.create();
String fileName = "SomeText.txt";
IndexOutput io = dir.createOutput(fileName);
RepeatableLongByteSequence bytesGenerator = new RepeatableLongByteSequence();
// It writes repeatable text
final int REPEATABLE_BUFFER_SIZE = 1501;
for (int i = 0; i < REPEATABLE_BUFFER_SIZE; i++) {
io.writeByte(bytesGenerator.nextByte());
}
io.flush();
assert io.length() == REPEATABLE_BUFFER_SIZE;
// Text to write on file with repeatable text
final String someText = "This is some text";
final byte[] someTextAsBytes = someText.getBytes();
// 4 points in random order where writing someText: at begin of file, at end of file, within a
// single chunk,
// between 2 chunks
final int[] pointers = {0, 635, REPEATABLE_BUFFER_SIZE, 135};
for (int i = 0; i < pointers.length; i++) {
io.seek(pointers[i]);
io.writeBytes(someTextAsBytes, someTextAsBytes.length);
}
io.close();
bytesGenerator.reset();
final long finalSize = REPEATABLE_BUFFER_SIZE + someTextAsBytes.length;
assert io.length() == finalSize;
assert io.length()
== DirectoryIntegrityCheck.deepCountFileSize(new FileCacheKey(INDEXNAME, fileName), cache);
int indexPointer = 0;
Arrays.sort(pointers);
byte[] buffer = null;
int chunkIndex = -1;
// now testing the stream is equal to the produced repeatable but including the edits at pointed
// positions
for (int i = 0; i < REPEATABLE_BUFFER_SIZE + someTextAsBytes.length; i++) {
if (i % BUFFER_SIZE == 0) {
buffer =
(byte[]) cache.get(new ChunkCacheKey(INDEXNAME, fileName, ++chunkIndex, BUFFER_SIZE));
}
byte predictableByte = bytesGenerator.nextByte();
if (i < pointers[indexPointer]) {
// Assert predictable text
AssertJUnit.assertEquals(predictableByte, buffer[i % BUFFER_SIZE]);
} else if (pointers[indexPointer] <= i
&& i < pointers[indexPointer] + someTextAsBytes.length) {
// Assert someText
AssertJUnit.assertEquals(
someTextAsBytes[i - pointers[indexPointer]], buffer[i % BUFFER_SIZE]);
}
if (i == pointers[indexPointer] + someTextAsBytes.length) {
// Change pointer
indexPointer++;
}
}
dir.close();
DirectoryIntegrityCheck.verifyDirectoryStructure(cache, INDEXNAME);
}
@Override
public void seek(long l) throws IOException {
tempOut.seek(l);
}
@Override
public void seek(long pos) throws IOException {
out.seek(pos);
}
