/*
* Copyright (C) 2014 Square, 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 okio;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import org.junit.Test;
import static java.util.Arrays.asList;
import static okio.TestUtil.repeat;
import static okio.Util.UTF_8;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
/**
* Tests solely for the behavior of Buffer's implementation. For generic BufferedSink or
* BufferedSource behavior use BufferedSinkTest or BufferedSourceTest, respectively.
*/
public final class BufferTest {
@Test public void readAndWriteUtf8() throws Exception {
Buffer buffer = new Buffer();
buffer.writeUtf8("ab");
assertEquals(2, buffer.size());
buffer.writeUtf8("cdef");
assertEquals(6, buffer.size());
assertEquals("abcd", buffer.readUtf8(4));
assertEquals(2, buffer.size());
assertEquals("ef", buffer.readUtf8(2));
assertEquals(0, buffer.size());
try {
buffer.readUtf8(1);
fail();
} catch (ArrayIndexOutOfBoundsException expected) {
}
}
@Test public void completeSegmentByteCountOnEmptyBuffer() throws Exception {
Buffer buffer = new Buffer();
assertEquals(0, buffer.completeSegmentByteCount());
}
@Test public void completeSegmentByteCountOnBufferWithFullSegments() throws Exception {
Buffer buffer = new Buffer();
buffer.writeUtf8(repeat('a', Segment.SIZE * 4));
assertEquals(Segment.SIZE * 4, buffer.completeSegmentByteCount());
}
@Test public void completeSegmentByteCountOnBufferWithIncompleteTailSegment() throws Exception {
Buffer buffer = new Buffer();
buffer.writeUtf8(repeat('a', Segment.SIZE * 4 - 10));
assertEquals(Segment.SIZE * 3, buffer.completeSegmentByteCount());
}
@Test public void toStringOnEmptyBuffer() throws Exception {
Buffer buffer = new Buffer();
assertEquals("Buffer[size=0]", buffer.toString());
}
@Test public void toStringOnSmallBufferIncludesContents() throws Exception {
Buffer buffer = new Buffer();
buffer.write(ByteString.decodeHex("a1b2c3d4e5f61a2b3c4d5e6f10203040"));
assertEquals("Buffer[size=16 data=a1b2c3d4e5f61a2b3c4d5e6f10203040]", buffer.toString());
}
@Test public void toStringOnLargeBufferIncludesMd5() throws Exception {
Buffer buffer = new Buffer();
buffer.write(ByteString.encodeUtf8("12345678901234567"));
assertEquals("Buffer[size=17 md5=2c9728a2138b2f25e9f89f99bdccf8db]", buffer.toString());
}
@Test public void toStringOnMultipleSegmentBuffer() throws Exception {
Buffer buffer = new Buffer();
buffer.writeUtf8(repeat('a', 6144));
assertEquals("Buffer[size=6144 md5=d890021f28522533c1cc1b9b1f83ce73]", buffer.toString());
}
@Test public void multipleSegmentBuffers() throws Exception {
Buffer buffer = new Buffer();
buffer.writeUtf8(repeat('a', 1000));
buffer.writeUtf8(repeat('b', 2500));
buffer.writeUtf8(repeat('c', 5000));
buffer.writeUtf8(repeat('d', 10000));
buffer.writeUtf8(repeat('e', 25000));
buffer.writeUtf8(repeat('f', 50000));
assertEquals(repeat('a', 999), buffer.readUtf8(999)); // a...a
assertEquals("a" + repeat('b', 2500) + "c", buffer.readUtf8(2502)); // ab...bc
assertEquals(repeat('c', 4998), buffer.readUtf8(4998)); // c...c
assertEquals("c" + repeat('d', 10000) + "e", buffer.readUtf8(10002)); // cd...de
assertEquals(repeat('e', 24998), buffer.readUtf8(24998)); // e...e
assertEquals("e" + repeat('f', 50000), buffer.readUtf8(50001)); // ef...f
assertEquals(0, buffer.size());
}
@Test public void fillAndDrainPool() throws Exception {
Buffer buffer = new Buffer();
// Take 2 * MAX_SIZE segments. This will drain the pool, even if other tests filled it.
buffer.write(new byte[(int) SegmentPool.MAX_SIZE]);
buffer.write(new byte[(int) SegmentPool.MAX_SIZE]);
assertEquals(0, SegmentPool.byteCount);
// Recycle MAX_SIZE segments. They're all in the pool.
buffer.readByteString(SegmentPool.MAX_SIZE);
assertEquals(SegmentPool.MAX_SIZE, SegmentPool.byteCount);
// Recycle MAX_SIZE more segments. The pool is full so they get garbage collected.
buffer.readByteString(SegmentPool.MAX_SIZE);
assertEquals(SegmentPool.MAX_SIZE, SegmentPool.byteCount);
// Take MAX_SIZE segments to drain the pool.
buffer.write(new byte[(int) SegmentPool.MAX_SIZE]);
assertEquals(0, SegmentPool.byteCount);
// Take MAX_SIZE more segments. The pool is drained so these will need to be allocated.
buffer.write(new byte[(int) SegmentPool.MAX_SIZE]);
assertEquals(0, SegmentPool.byteCount);
}
@Test public void moveBytesBetweenBuffersShareSegment() throws Exception {
int size = (Segment.SIZE / 2) - 1;
List<Integer> segmentSizes = moveBytesBetweenBuffers(repeat('a', size), repeat('b', size));
assertEquals(asList(size * 2), segmentSizes);
}
@Test public void moveBytesBetweenBuffersReassignSegment() throws Exception {
int size = (Segment.SIZE / 2) + 1;
List<Integer> segmentSizes = moveBytesBetweenBuffers(repeat('a', size), repeat('b', size));
assertEquals(asList(size, size), segmentSizes);
}
@Test public void moveBytesBetweenBuffersMultipleSegments() throws Exception {
int size = 3 * Segment.SIZE + 1;
List<Integer> segmentSizes = moveBytesBetweenBuffers(repeat('a', size), repeat('b', size));
assertEquals(asList(Segment.SIZE, Segment.SIZE, Segment.SIZE, 1,
Segment.SIZE, Segment.SIZE, Segment.SIZE, 1), segmentSizes);
}
private List<Integer> moveBytesBetweenBuffers(String... contents) throws IOException {
StringBuilder expected = new StringBuilder();
Buffer buffer = new Buffer();
for (String s : contents) {
Buffer source = new Buffer();
source.writeUtf8(s);
buffer.writeAll(source);
expected.append(s);
}
List<Integer> segmentSizes = buffer.segmentSizes();
assertEquals(expected.toString(), buffer.readUtf8(expected.length()));
return segmentSizes;
}
/** The big part of source's first segment is being moved. */
@Test public void writeSplitSourceBufferLeft() throws Exception {
int writeSize = Segment.SIZE / 2 + 1;
Buffer sink = new Buffer();
sink.writeUtf8(repeat('b', Segment.SIZE - 10));
Buffer source = new Buffer();
source.writeUtf8(repeat('a', Segment.SIZE * 2));
sink.write(source, writeSize);
assertEquals(asList(Segment.SIZE - 10, writeSize), sink.segmentSizes());
assertEquals(asList(Segment.SIZE - writeSize, Segment.SIZE), source.segmentSizes());
}
/** The big part of source's first segment is staying put. */
@Test public void writeSplitSourceBufferRight() throws Exception {
int writeSize = Segment.SIZE / 2 - 1;
Buffer sink = new Buffer();
sink.writeUtf8(repeat('b', Segment.SIZE - 10));
Buffer source = new Buffer();
source.writeUtf8(repeat('a', Segment.SIZE * 2));
sink.write(source, writeSize);
assertEquals(asList(Segment.SIZE - 10, writeSize), sink.segmentSizes());
assertEquals(asList(Segment.SIZE - writeSize, Segment.SIZE), source.segmentSizes());
}
@Test public void writePrefixDoesntSplit() throws Exception {
Buffer sink = new Buffer();
sink.writeUtf8(repeat('b', 10));
Buffer source = new Buffer();
source.writeUtf8(repeat('a', Segment.SIZE * 2));
sink.write(source, 20);
assertEquals(asList(30), sink.segmentSizes());
assertEquals(asList(Segment.SIZE - 20, Segment.SIZE), source.segmentSizes());
assertEquals(30, sink.size());
assertEquals(Segment.SIZE * 2 - 20, source.size());
}
@Test public void writePrefixDoesntSplitButRequiresCompact() throws Exception {
Buffer sink = new Buffer();
sink.writeUtf8(repeat('b', Segment.SIZE - 10)); // limit = size - 10
sink.readUtf8(Segment.SIZE - 20); // pos = size = 20
Buffer source = new Buffer();
source.writeUtf8(repeat('a', Segment.SIZE * 2));
sink.write(source, 20);
assertEquals(asList(30), sink.segmentSizes());
assertEquals(asList(Segment.SIZE - 20, Segment.SIZE), source.segmentSizes());
assertEquals(30, sink.size());
assertEquals(Segment.SIZE * 2 - 20, source.size());
}
@Test public void copyToSpanningSegments() throws Exception {
Buffer source = new Buffer();
source.writeUtf8(repeat('a', Segment.SIZE * 2));
source.writeUtf8(repeat('b', Segment.SIZE * 2));
ByteArrayOutputStream out = new ByteArrayOutputStream();
source.copyTo(out, 10, Segment.SIZE * 3);
assertEquals(repeat('a', Segment.SIZE * 2 - 10) + repeat('b', Segment.SIZE + 10),
out.toString());
assertEquals(repeat('a', Segment.SIZE * 2) + repeat('b', Segment.SIZE * 2),
source.readUtf8(Segment.SIZE * 4));
}
@Test public void copyToStream() throws Exception {
Buffer buffer = new Buffer().writeUtf8("hello, world!");
ByteArrayOutputStream out = new ByteArrayOutputStream();
buffer.copyTo(out);
String outString = new String(out.toByteArray(), UTF_8);
assertEquals("hello, world!", outString);
assertEquals("hello, world!", buffer.readUtf8());
}
@Test public void writeToSpanningSegments() throws Exception {
Buffer buffer = new Buffer();
buffer.writeUtf8(repeat('a', Segment.SIZE * 2));
buffer.writeUtf8(repeat('b', Segment.SIZE * 2));
ByteArrayOutputStream out = new ByteArrayOutputStream();
buffer.skip(10);
buffer.writeTo(out, Segment.SIZE * 3);
assertEquals(repeat('a', Segment.SIZE * 2 - 10) + repeat('b', Segment.SIZE + 10),
out.toString());
assertEquals(repeat('b', Segment.SIZE - 10), buffer.readUtf8(buffer.size));
}
@Test public void writeToStream() throws Exception {
Buffer buffer = new Buffer().writeUtf8("hello, world!");
ByteArrayOutputStream out = new ByteArrayOutputStream();
buffer.writeTo(out);
String outString = new String(out.toByteArray(), UTF_8);
assertEquals("hello, world!", outString);
assertEquals(0, buffer.size());
}
@Test public void readFromStream() throws Exception {
InputStream in = new ByteArrayInputStream("hello, world!".getBytes(UTF_8));
Buffer buffer = new Buffer();
buffer.readFrom(in);
String out = buffer.readUtf8();
assertEquals("hello, world!", out);
}
@Test public void readFromSpanningSegments() throws Exception {
InputStream in = new ByteArrayInputStream("hello, world!".getBytes(UTF_8));
Buffer buffer = new Buffer().writeUtf8(repeat('a', Segment.SIZE - 10));
buffer.readFrom(in);
String out = buffer.readUtf8();
assertEquals(repeat('a', Segment.SIZE - 10) + "hello, world!", out);
}
@Test public void readFromStreamWithCount() throws Exception {
InputStream in = new ByteArrayInputStream("hello, world!".getBytes(UTF_8));
Buffer buffer = new Buffer();
buffer.readFrom(in, 10);
String out = buffer.readUtf8();
assertEquals("hello, wor", out);
}
@Test public void moveAllRequestedBytesWithRead() throws Exception {
Buffer sink = new Buffer();
sink.writeUtf8(repeat('a', 10));
Buffer source = new Buffer();
source.writeUtf8(repeat('b', 15));
assertEquals(10, source.read(sink, 10));
assertEquals(20, sink.size());
assertEquals(5, source.size());
assertEquals(repeat('a', 10) + repeat('b', 10), sink.readUtf8(20));
}
@Test public void moveFewerThanRequestedBytesWithRead() throws Exception {
Buffer sink = new Buffer();
sink.writeUtf8(repeat('a', 10));
Buffer source = new Buffer();
source.writeUtf8(repeat('b', 20));
assertEquals(20, source.read(sink, 25));
assertEquals(30, sink.size());
assertEquals(0, source.size());
assertEquals(repeat('a', 10) + repeat('b', 20), sink.readUtf8(30));
}
@Test public void indexOfWithOffset() throws Exception {
Buffer buffer = new Buffer();
int halfSegment = Segment.SIZE / 2;
buffer.writeUtf8(repeat('a', halfSegment));
buffer.writeUtf8(repeat('b', halfSegment));
buffer.writeUtf8(repeat('c', halfSegment));
buffer.writeUtf8(repeat('d', halfSegment));
assertEquals(0, buffer.indexOf((byte) 'a', 0));
assertEquals(halfSegment - 1, buffer.indexOf((byte) 'a', halfSegment - 1));
assertEquals(halfSegment, buffer.indexOf((byte) 'b', halfSegment - 1));
assertEquals(halfSegment * 2, buffer.indexOf((byte) 'c', halfSegment - 1));
assertEquals(halfSegment * 3, buffer.indexOf((byte) 'd', halfSegment - 1));
assertEquals(halfSegment * 3, buffer.indexOf((byte) 'd', halfSegment * 2));
assertEquals(halfSegment * 3, buffer.indexOf((byte) 'd', halfSegment * 3));
assertEquals(halfSegment * 4 - 1, buffer.indexOf((byte) 'd', halfSegment * 4 - 1));
}
@Test public void byteAt() throws Exception {
Buffer buffer = new Buffer();
buffer.writeUtf8("a");
buffer.writeUtf8(repeat('b', Segment.SIZE));
buffer.writeUtf8("c");
assertEquals('a', buffer.getByte(0));
assertEquals('a', buffer.getByte(0)); // getByte doesn't mutate!
assertEquals('c', buffer.getByte(buffer.size - 1));
assertEquals('b', buffer.getByte(buffer.size - 2));
assertEquals('b', buffer.getByte(buffer.size - 3));
}
@Test public void getByteOfEmptyBuffer() throws Exception {
Buffer buffer = new Buffer();
try {
buffer.getByte(0);
fail();
} catch (IndexOutOfBoundsException expected) {
}
}
@Test public void writePrefixToEmptyBuffer() throws IOException {
Buffer sink = new Buffer();
Buffer source = new Buffer();
source.writeUtf8("abcd");
sink.write(source, 2);
assertEquals("ab", sink.readUtf8(2));
}
@Test public void cloneDoesNotObserveWritesToOriginal() throws Exception {
Buffer original = new Buffer();
Buffer clone = original.clone();
original.writeUtf8("abc");
assertEquals(0, clone.size());
}
@Test public void cloneDoesNotObserveReadsFromOriginal() throws Exception {
Buffer original = new Buffer();
original.writeUtf8("abc");
Buffer clone = original.clone();
assertEquals("abc", original.readUtf8(3));
assertEquals(3, clone.size());
assertEquals("ab", clone.readUtf8(2));
}
@Test public void originalDoesNotObserveWritesToClone() throws Exception {
Buffer original = new Buffer();
Buffer clone = original.clone();
clone.writeUtf8("abc");
assertEquals(0, original.size());
}
@Test public void originalDoesNotObserveReadsFromClone() throws Exception {
Buffer original = new Buffer();
original.writeUtf8("abc");
Buffer clone = original.clone();
assertEquals("abc", clone.readUtf8(3));
assertEquals(3, original.size());
assertEquals("ab", original.readUtf8(2));
}
@Test public void cloneMultipleSegments() throws Exception {
Buffer original = new Buffer();
original.writeUtf8(repeat('a', Segment.SIZE * 3));
Buffer clone = original.clone();
original.writeUtf8(repeat('b', Segment.SIZE * 3));
clone.writeUtf8(repeat('c', Segment.SIZE * 3));
assertEquals(repeat('a', Segment.SIZE * 3) + repeat('b', Segment.SIZE * 3),
original.readUtf8(Segment.SIZE * 6));
assertEquals(repeat('a', Segment.SIZE * 3) + repeat('c', Segment.SIZE * 3),
clone.readUtf8(Segment.SIZE * 6));
}
@Test public void equalsAndHashCodeEmpty() throws Exception {
Buffer a = new Buffer();
Buffer b = new Buffer();
assertTrue(a.equals(b));
assertTrue(a.hashCode() == b.hashCode());
}
@Test public void equalsAndHashCode() throws Exception {
Buffer a = new Buffer().writeUtf8("dog");
Buffer b = new Buffer().writeUtf8("hotdog");
assertFalse(a.equals(b));
assertFalse(a.hashCode() == b.hashCode());
b.readUtf8(3); // Leaves b containing 'dog'.
assertTrue(a.equals(b));
assertTrue(a.hashCode() == b.hashCode());
}
@Test public void equalsAndHashCodeSpanningSegments() throws Exception {
byte[] data = new byte[1024 * 1024];
Random dice = new Random(0);
dice.nextBytes(data);
Buffer a = bufferWithRandomSegmentLayout(dice, data);
Buffer b = bufferWithRandomSegmentLayout(dice, data);
assertTrue(a.equals(b));
assertTrue(a.hashCode() == b.hashCode());
data[data.length / 2]++; // Change a single byte.
Buffer c = bufferWithRandomSegmentLayout(dice, data);
assertFalse(a.equals(c));
assertFalse(a.hashCode() == c.hashCode());
}
@Test public void bufferInputStreamByteByByte() throws Exception {
Buffer source = new Buffer();
source.writeUtf8("abc");
InputStream in = source.inputStream();
assertEquals(3, in.available());
assertEquals('a', in.read());
assertEquals('b', in.read());
assertEquals('c', in.read());
assertEquals(-1, in.read());
assertEquals(0, in.available());
}
@Test public void bufferInputStreamBulkReads() throws Exception {
Buffer source = new Buffer();
source.writeUtf8("abc");
byte[] byteArray = new byte[4];
Arrays.fill(byteArray, (byte) -5);
InputStream in = source.inputStream();
assertEquals(3, in.read(byteArray));
assertEquals("[97, 98, 99, -5]", Arrays.toString(byteArray));
Arrays.fill(byteArray, (byte) -7);
assertEquals(-1, in.read(byteArray));
assertEquals("[-7, -7, -7, -7]", Arrays.toString(byteArray));
}
/**
* When writing data that's already buffered, there's no reason to page the
* data by segment.
*/
@Test public void readAllWritesAllSegmentsAtOnce() throws Exception {
Buffer write1 = new Buffer().writeUtf8(""
+ TestUtil.repeat('a', Segment.SIZE)
+ TestUtil.repeat('b', Segment.SIZE)
+ TestUtil.repeat('c', Segment.SIZE));
Buffer source = new Buffer().writeUtf8(""
+ TestUtil.repeat('a', Segment.SIZE)
+ TestUtil.repeat('b', Segment.SIZE)
+ TestUtil.repeat('c', Segment.SIZE));
MockSink mockSink = new MockSink();
assertEquals(Segment.SIZE * 3, source.readAll(mockSink));
assertEquals(0, source.size());
mockSink.assertLog("write(" + write1 + ", " + write1.size() + ")");
}
@Test public void writeAllMultipleSegments() throws Exception {
Buffer source = new Buffer().writeUtf8(TestUtil.repeat('a', Segment.SIZE * 3));
Buffer sink = new Buffer();
assertEquals(Segment.SIZE * 3, sink.writeAll(source));
assertEquals(0, source.size());
assertEquals(TestUtil.repeat('a', Segment.SIZE * 3), sink.readUtf8());
}
@Test public void copyTo() throws Exception {
Buffer source = new Buffer();
source.writeUtf8("party");
Buffer target = new Buffer();
source.copyTo(target, 1, 3);
assertEquals("art", target.readUtf8());
assertEquals("party", source.readUtf8());
}
@Test public void copyToOnSegmentBoundary() throws Exception {
String as = repeat('a', Segment.SIZE);
String bs = repeat('b', Segment.SIZE);
String cs = repeat('c', Segment.SIZE);
String ds = repeat('d', Segment.SIZE);
Buffer source = new Buffer();
source.writeUtf8(as);
source.writeUtf8(bs);
source.writeUtf8(cs);
Buffer target = new Buffer();
target.writeUtf8(ds);
source.copyTo(target, as.length(), bs.length() + cs.length());
assertEquals(ds + bs + cs, target.readUtf8());
}
@Test public void copyToOffSegmentBoundary() throws Exception {
String as = repeat('a', Segment.SIZE - 1);
String bs = repeat('b', Segment.SIZE + 2);
String cs = repeat('c', Segment.SIZE - 4);
String ds = repeat('d', Segment.SIZE + 8);
Buffer source = new Buffer();
source.writeUtf8(as);
source.writeUtf8(bs);
source.writeUtf8(cs);
Buffer target = new Buffer();
target.writeUtf8(ds);
source.copyTo(target, as.length(), bs.length() + cs.length());
assertEquals(ds + bs + cs, target.readUtf8());
}
@Test public void copyToSourceAndTargetCanBeTheSame() throws Exception {
String as = repeat('a', Segment.SIZE);
String bs = repeat('b', Segment.SIZE);
Buffer source = new Buffer();
source.writeUtf8(as);
source.writeUtf8(bs);
source.copyTo(source, 0, source.size());
assertEquals(as + bs + as + bs, source.readUtf8());
}
@Test public void copyToEmptySource() throws Exception {
Buffer source = new Buffer();
Buffer target = new Buffer().writeUtf8("aaa");
source.copyTo(target, 0L, 0L);
assertEquals("", source.readUtf8());
assertEquals("aaa", target.readUtf8());
}
@Test public void copyToEmptyTarget() throws Exception {
Buffer source = new Buffer().writeUtf8("aaa");
Buffer target = new Buffer();
source.copyTo(target, 0L, 3L);
assertEquals("aaa", source.readUtf8());
assertEquals("aaa", target.readUtf8());
}
/**
* Returns a new buffer containing the data in {@code data}, and a segment
* layout determined by {@code dice}.
*/
private Buffer bufferWithRandomSegmentLayout(Random dice, byte[] data) throws IOException {
Buffer result = new Buffer();
// Writing to result directly will yield packed segments. Instead, write to
// other buffers, then write those buffers to result.
for (int pos = 0, byteCount; pos < data.length; pos += byteCount) {
byteCount = (Segment.SIZE / 2) + dice.nextInt(Segment.SIZE / 2);
if (byteCount > data.length - pos) byteCount = data.length - pos;
int offset = dice.nextInt(Segment.SIZE - byteCount);
Buffer segment = new Buffer();
segment.write(new byte[offset]);
segment.write(data, pos, byteCount);
segment.skip(offset);
result.write(segment, byteCount);
}
return result;
}
}