@Test public void bufferedSinkFlush() throws IOException { Buffer sink = new Buffer(); BufferedSink bufferedSink = new RealBufferedSink(sink); bufferedSink.writeByte('a'); assertEquals(0, sink.size()); bufferedSink.flush(); assertEquals(0, bufferedSink.buffer().size()); assertEquals(1, sink.size()); }
@Test public void bufferedSinkEmitsTailWhenItIsComplete() throws IOException { Buffer sink = new Buffer(); BufferedSink bufferedSink = new RealBufferedSink(sink); bufferedSink.writeUtf8(repeat('a', Segment.SIZE - 1)); assertEquals(0, sink.size()); bufferedSink.writeByte(0); assertEquals(Segment.SIZE, sink.size()); assertEquals(0, bufferedSink.buffer().size()); }
@Test public void bytesNotEmittedToSinkWithoutFlush() throws Exception { Buffer sink = new Buffer(); BufferedSink bufferedSink = new RealBufferedSink(sink); bufferedSink.writeUtf8("abc"); assertEquals(0, sink.size()); }
@Test public void incompleteSegmentsNotEmitted() throws Exception { Buffer sink = new Buffer(); BufferedSink bufferedSink = new RealBufferedSink(sink); bufferedSink.writeUtf8(repeat('a', Segment.SIZE * 3 - 1)); assertEquals(Segment.SIZE * 2, sink.size()); }
@Test public void bufferedSinkEmitMultipleSegments() throws IOException { Buffer sink = new Buffer(); BufferedSink bufferedSink = new RealBufferedSink(sink); bufferedSink.writeUtf8(repeat('a', Segment.SIZE * 4 - 1)); assertEquals(Segment.SIZE * 3, sink.size()); assertEquals(Segment.SIZE - 1, bufferedSink.buffer().size()); }
@Test public void readExhaustedSource() throws Exception { Buffer sink = new Buffer(); sink.writeUtf8(repeat('a', 10)); assertEquals(-1, source.read(sink, 10)); assertEquals(10, sink.size()); assertTrue(source.exhausted()); }
@Test public void readZeroBytesFromSource() throws Exception { Buffer sink = new Buffer(); sink.writeUtf8(repeat('a', 10)); // Either 0 or -1 is reasonable here. For consistency with Android's // ByteArrayInputStream we return 0. assertEquals(-1, source.read(sink, 0)); assertEquals(10, sink.size()); assertTrue(source.exhausted()); }
@Test public void readFullyByteArray() throws IOException { Buffer data = new Buffer(); data.writeUtf8("Hello").writeUtf8(repeat('e', Segment.SIZE)); byte[] expected = data.clone().readByteArray(); sink.write(data, data.size()); byte[] sink = new byte[Segment.SIZE + 5]; source.readFully(sink); assertByteArraysEquals(expected, sink); }
@Test public void writeAllWritesOneSegmentAtATime() throws IOException { Buffer write1 = new Buffer().writeUtf8(TestUtil.repeat('a', Segment.SIZE)); Buffer write2 = new Buffer().writeUtf8(TestUtil.repeat('b', Segment.SIZE)); Buffer write3 = new Buffer().writeUtf8(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(); BufferedSink bufferedSink = Okio.buffer(mockSink); assertEquals(Segment.SIZE * 3, bufferedSink.writeAll(source)); mockSink.assertLog( "write(" + write1 + ", " + write1.size() + ")", "write(" + write2 + ", " + write2.size() + ")", "write(" + write3 + ", " + write3.size() + ")"); }
@Test public void sinkFromOutputStream() throws Exception { Buffer data = new Buffer(); data.writeUtf8("a"); data.writeUtf8(repeat('b', 9998)); data.writeUtf8("c"); ByteArrayOutputStream out = new ByteArrayOutputStream(); Sink sink = Okio.sink(out); sink.write(data, 3); assertEquals("abb", out.toString("UTF-8")); sink.write(data, data.size()); assertEquals("a" + repeat('b', 9998) + "c", out.toString("UTF-8")); }
@Test public void sourceFromInputStream() throws Exception { InputStream in = new ByteArrayInputStream(("a" + repeat('b', Segment.SIZE * 2) + "c").getBytes(UTF_8)); // Source: ab...bc Source source = Okio.source(in); Buffer sink = new Buffer(); // Source: b...bc. Sink: abb. assertEquals(3, source.read(sink, 3)); assertEquals("abb", sink.readUtf8(3)); // Source: b...bc. Sink: b...b. assertEquals(Segment.SIZE, source.read(sink, 20000)); assertEquals(repeat('b', Segment.SIZE), sink.readUtf8(sink.size())); // Source: b...bc. Sink: b...bc. assertEquals(Segment.SIZE - 1, source.read(sink, 20000)); assertEquals(repeat('b', Segment.SIZE - 2) + "c", sink.readUtf8(sink.size())); // Source and sink are empty. assertEquals(-1, source.read(sink, 1)); }
public final void write(Buffer source, long byteCount) throws IOException { Util.checkOffsetAndCount(source.size, 0, byteCount); while (byteCount > 0) { Segment head = source.head; int toDeflate = (int) Math.min(byteCount, (long) (head.limit - head.pos)); this.deflater.setInput(head.data, head.pos, toDeflate); deflate(false); source.size -= (long) toDeflate; head.pos += toDeflate; if (head.pos == head.limit) { source.head = head.pop(); SegmentPool.recycle(head); } byteCount -= (long) toDeflate; } }
@IgnoreJRERequirement private void deflate(boolean syncFlush) throws IOException { Buffer buffer = this.sink.buffer(); while (true) { Segment s = buffer.writableSegment(1); int deflated = syncFlush ? this.deflater.deflate(s.data, s.limit, 2048 - s.limit, 2) : this.deflater.deflate(s.data, s.limit, 2048 - s.limit); if (deflated > 0) { s.limit += deflated; buffer.size += (long) deflated; this.sink.emitCompleteSegments(); } else if (this.deflater.needsInput()) { break; } } if (s.pos == s.limit) { buffer.head = s.pop(); SegmentPool.recycle(s); } }
public void testLegacy() { // 1. Tests of old methods. Buffer buf = new Buffer(4); Iterator iter = null; assertEquals(4, buf.getCapacity()); assertEquals(0, buf.getSize()); iter = buf.iterator(); assertTrue(!iter.hasNext()); try { iter.next(); assertTrue(false); } catch (NoSuchElementException e) { assertTrue(true); } buf.add("test"); assertEquals(1, buf.getSize()); iter = buf.iterator(); assertTrue(iter.hasNext()); assertEquals("test", iter.next()); assertTrue(!iter.hasNext()); try { iter.next(); assertTrue(false); } catch (NoSuchElementException e) { } buf.add("test2"); assertEquals(2, buf.getSize()); buf.add("test3"); assertEquals(3, buf.getSize()); iter = buf.iterator(); assertTrue(iter.hasNext()); assertEquals("test3", iter.next()); assertTrue(iter.hasNext()); assertEquals("test2", iter.next()); assertTrue(iter.hasNext()); assertEquals("test", iter.next()); assertTrue(!iter.hasNext()); buf.add("test4"); assertEquals(4, buf.getSize()); buf.add("test5"); assertEquals(4, buf.getSize()); iter = buf.iterator(); assertTrue(iter.hasNext()); assertEquals("test5", iter.next()); assertTrue(iter.hasNext()); assertEquals("test4", iter.next()); assertTrue(iter.hasNext()); assertEquals("test3", iter.next()); assertTrue(iter.hasNext()); assertEquals("test2", iter.next()); assertTrue(!iter.hasNext()); buf.add("test6"); assertEquals(4, buf.getSize()); // 2. Tests of new methods. These are definitely not sufficient. buf = new Buffer(4); assertEquals(0, buf.getSize()); assertNull(buf.addLast("a")); assertEquals(1, buf.getSize()); assertNull(buf.addLast("b")); assertEquals(2, buf.getSize()); assertNull(buf.addLast("c")); assertEquals(3, buf.getSize()); assertNull(buf.addLast("d")); assertEquals(4, buf.getSize()); assertEquals("a", buf.first()); assertEquals("a", buf.removeFirst()); assertEquals(3, buf.getSize()); assertEquals("b", buf.first()); assertEquals("b", buf.removeFirst()); assertEquals(2, buf.getSize()); assertNull(buf.addFirst("b")); assertEquals(3, buf.getSize()); assertNull(buf.addFirst("a")); assertEquals(4, buf.getSize()); // buf=[a b c d] assertEquals("a", buf.addLast("e")); // buf=[b c d e] assertEquals("e", buf.last()); assertEquals("b", buf.first()); assertEquals("e", buf.removeLast()); assertEquals("d", buf.removeLast()); buf = new Buffer(4); iter = buf.iterator(); buf.addFirst("a"); try { iter.hasNext(); assertTrue(false); } catch (ConcurrentModificationException e) { assertTrue(true); } buf = new Buffer(4); buf.addFirst("a"); buf.addLast("b"); buf.clear(); assertEquals(0, buf.getSize()); iter = buf.iterator(); assertTrue(!iter.hasNext()); // 3. Tests of get and set. buf = new Buffer(3); try { buf.get(0); assertTrue(false); } catch (IndexOutOfBoundsException e) { } try { buf.get(-1); assertTrue(false); } catch (IndexOutOfBoundsException e) { } buf.addLast("a"); buf.addLast("b"); buf.addLast("c"); buf.addLast("d"); // clobbers a! assertEquals("b", buf.get(0)); assertEquals("c", buf.get(1)); assertEquals("d", buf.get(2)); buf.set(2, "bb"); assertEquals("bb", buf.get(2)); // 4. Tests of remove and removeAll methods. buf = new Buffer(4); buf.addLast("a"); buf.addLast("b"); buf.addLast("c"); buf.addLast("d"); try { buf.remove(-1); assertTrue(false); } catch (IndexOutOfBoundsException e) { } assertEquals("a", (buf.remove(0))); assertEquals(3, buf.size()); assertEquals("b", buf.get(0)); assertEquals("c", buf.get(1)); assertEquals("d", buf.get(2)); buf = new Buffer(4); buf.addLast("x"); buf.addLast("y"); buf.addLast("a"); buf.addLast("b"); buf.addLast("c"); buf.addLast("d"); try { buf.remove(5); assertTrue(false); } catch (IndexOutOfBoundsException e) { } assertEquals("a", (buf.remove(0))); assertEquals(3, buf.size()); assertEquals("b", buf.get(0)); assertEquals("c", buf.get(1)); assertEquals("d", buf.get(2)); buf = new Buffer(4); buf.addLast("a"); buf.addLast("b"); buf.addLast("c"); buf.addLast("d"); try { buf.remove(5); assertTrue(false); } catch (IndexOutOfBoundsException e) { } assertEquals("d", buf.remove(3)); assertEquals(3, buf.size()); assertEquals("a", buf.get(0)); assertEquals("b", buf.get(1)); assertEquals("c", buf.get(2)); buf = new Buffer(4); buf.addLast("a"); buf.addLast("b"); buf.addLast("c"); buf.addLast("d"); try { buf.remove(5); assertTrue(false); } catch (IndexOutOfBoundsException e) { } assertEquals("b", buf.remove(1)); assertEquals(3, buf.size()); assertEquals("a", buf.get(0)); assertEquals("c", buf.get(1)); assertEquals("d", buf.get(2)); buf = new Buffer(4); buf.addLast("b"); buf.addLast("b"); buf.addLast("c"); buf.addLast("d"); assertTrue(buf.remove("d")); assertTrue(buf.remove("b")); assertEquals(2, buf.size()); assertEquals("b", buf.get(0)); assertEquals("c", buf.get(1)); buf = new Buffer(4); buf.addLast("b"); buf.addLast("b"); buf.addLast("c"); buf.addLast("b"); assertTrue(buf.removeAll("b")); assertEquals(1, buf.size()); assertEquals("c", buf.get(0)); // 5. Test clone() method. buf = new Buffer(2); buf.addLast("a"); buf.addLast("b"); Buffer buf2 = new Buffer(buf); assertEquals(buf2.size(), buf.size()); assertEquals(buf2.getCapacity(), buf.getCapacity()); assertEquals(buf2.first(), buf.first()); assertEquals(buf2.last(), buf.last()); assertNotNull(buf.removeFirst()); // buf2 unmodified assertEquals(1, buf.size()); assertEquals(2, buf2.size()); assertEquals("b", buf.first()); assertEquals("a", buf2.first()); assertEquals("b", buf2.last()); }
private void doWriteToSocket() throws IOException { writeNumber(sockout, buf.size()); sockout.write(' '); buf.writeTo(sockout); sockout.flush(); }