/*
* Copyright 2010 NCHOVY
*
* 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 org.krakenapps.pcap;
import static org.junit.Assert.*;
import java.nio.BufferUnderflowException;
import java.nio.InvalidMarkException;
import org.junit.Test;
import org.krakenapps.pcap.util.Buffer;
import org.krakenapps.pcap.util.ChainBuffer;
public class ChainBufferTest {
private Buffer initBuffer() {
Buffer buffer = new ChainBuffer();
byte[] testArray = new byte[] { 1, 2 };
byte[] testArray2 = new byte[] { 3, 4, 5 };
byte[] testArray3 = new byte[] { 6, 7, 8, 9 };
byte[] testArray4 = new byte[] { 10, 11 };
byte[] testArray5 = new byte[] { 12, 13, 14 };
buffer.addLast(testArray);
buffer.addLast(testArray2);
buffer.addLast(testArray3);
buffer.addLast(testArray4);
buffer.addLast(testArray5);
return buffer;
}
private Buffer initBuffer2() {
Buffer buffer = new ChainBuffer();
byte[] testArray = new byte[] { 1, 2, 3, 4 };
byte[] testArray2 = new byte[] { 5, 6, 7, 8, 9 };
byte[] testArray3 = new byte[] { 10, 11, 12 };
buffer.addLast(testArray);
buffer.addLast(testArray2);
buffer.addLast(testArray3);
return buffer;
}
private Buffer initBuffer3() {
Buffer buffer = initBuffer();
Buffer buffer2 = new ChainBuffer();
byte[] testArray6 = new byte[] { 101, 102, 103, 104 };
byte[] testArray7 = new byte[] { 105, 106, 107, 108, 109 };
byte[] testArray8 = new byte[] { 110, 111, 112 };
buffer2.addLast(testArray6);
buffer2.addLast(testArray7);
buffer2.addLast(testArray8);
Buffer buffer3 = new ChainBuffer();
byte[] testArray9 = new byte[] { 21, 22, 23 };
byte[] testArray10 = new byte[] { 24, 25 };
byte[] testArray11 = new byte[] { 26, 27, 28, 29 };
byte[] testArray12 = new byte[] { 30, 31, 32, 33, 34, 35 };
buffer3.addLast(testArray9);
buffer3.addLast(testArray10);
buffer3.addLast(testArray11);
buffer3.addLast(testArray12);
buffer.addLast(buffer2);
buffer.addLast(buffer3);
return buffer;
}
private Buffer initBuffer4() {
Buffer buffer = initBuffer();
Buffer buffer2 = new ChainBuffer();
byte[] testArray6 = new byte[] { 101, 102, 103, 104 };
byte[] testArray7 = new byte[] { 105, 106, 107, 108, 109 };
byte[] testArray8 = new byte[] { 110, 111, 112 };
buffer2.addLast(testArray6);
buffer2.addLast(testArray7);
buffer2.addLast(testArray8);
Buffer buffer3 = new ChainBuffer();
byte[] testArray9 = new byte[] { 21, 22, 23 };
byte[] testArray10 = new byte[] { 24, 25 };
byte[] testArray11 = new byte[] { 26, 27, 28, 29 };
byte[] testArray12 = new byte[] { 30, 31, 32, 33, 34, 35 };
buffer3.addLast(testArray9);
buffer3.addLast(testArray10);
buffer3.addLast(testArray11);
buffer3.addLast(testArray12);
buffer2.get();
buffer2.get();
buffer2.get();
buffer.addLast(buffer2);
buffer3.get();
buffer3.get();
buffer3.get();
buffer.addLast(buffer3);
return buffer;
}
@Test
public void positionTest() {
Buffer buffer = initBuffer4();
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
buffer.mark();
byte[] temp = new byte[20];
buffer.gets(temp);
assertEquals(22, buffer.position());
buffer.reset();
assertEquals(2, buffer.position());
}
@Test
public void positionTest2() {
Buffer buffer = initBuffer4();
assertEquals(0, buffer.position());
assertEquals(1, buffer.get());
assertEquals(1, buffer.position());
assertEquals(2, buffer.get());
assertEquals(2, buffer.position());
buffer.mark();
buffer.reset();
assertEquals(2, buffer.position());
}
@Test
public void positionTest3() {
Buffer buffer = initBuffer4();
byte[] temp = new byte[13];
buffer.gets(temp);
assertEquals(13, buffer.position());
}
@Test
public void positionIntTest() {
Buffer buffer = initBuffer3();
byte[] temp = new byte[13];
buffer.gets(temp);
buffer.position(19);
assertEquals(106, buffer.get());
}
@Test
public void positionIntTest2() {
Buffer buffer = initBuffer4();
byte[] temp = new byte[15];
buffer.gets(temp);
buffer.position(21);
assertEquals(108, buffer.get());
}
@Test(expected = IllegalArgumentException.class)
public void positionIntTest3() {
Buffer buffer = initBuffer4();
byte[] temp = new byte[15];
buffer.gets(temp);
buffer.position(-1);
assertEquals(111, buffer.get());
}
@Test
public void getTest() {
/* Test: buffer.get(), buffer.reset(), buffer.discardReadBytes() */
Buffer buffer = initBuffer2();
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
buffer.rewind();
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
assertEquals(3, buffer.get());
assertEquals(4, buffer.get());
buffer.discardReadBytes();
assertEquals(5, buffer.get());
assertEquals(6, buffer.get());
assertEquals(7, buffer.get());
buffer.rewind();
assertEquals(5, buffer.get());
assertEquals(6, buffer.get());
assertEquals(7, buffer.get());
}
@Test(expected = BufferUnderflowException.class)
public void getBufferUnderflowTest() {
/* Test: buffer.get(), catch BufferUnderflowException */
Buffer buffer = initBuffer2();
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
assertEquals(3, buffer.get());
assertEquals(4, buffer.get());
assertEquals(5, buffer.get());
assertEquals(6, buffer.get());
assertEquals(7, buffer.get());
assertEquals(8, buffer.get());
assertEquals(9, buffer.get());
assertEquals(10, buffer.get());
assertEquals(11, buffer.get());
assertEquals(12, buffer.get());
buffer.get();
}
@Test
public void getShortIntTest() {
/* Test: buffer.getShort(), buffer.getInt() */
Buffer buffer = new ChainBuffer();
byte[] testArray = new byte[] { 1, 2 };
byte[] testArray2 = new byte[] { 3, 4, 5 };
byte[] testArray3 = new byte[] { 6, 7, 8, 9 };
byte[] testArray4 = new byte[] { 10, 11 };
byte[] testArray5 = new byte[] { 12, 13, 14, 15 };
buffer.addLast(testArray);
buffer.addLast(testArray2);
buffer.addLast(testArray3);
buffer.addLast(testArray4);
buffer.addLast(testArray5);
assertEquals(0x01, buffer.get());
assertEquals(0x0203, buffer.getShort());
assertEquals(0x0405, buffer.getShort());
assertEquals(0x06, buffer.get());
assertEquals(0x0708090a, buffer.getInt());
}
@Test
public void getStringTest() {
Buffer buffer = new ChainBuffer();
byte[] testArray = new byte[] { 76, 79, 86, 69 };
byte[] testArray2 = new byte[] { 83, 69, 82 };
byte[] testArray3 = new byte[] { 89, 85, 78, 71 };
buffer.addLast(testArray);
buffer.addLast(testArray2);
buffer.addLast(testArray3);
String s1 = buffer.getString(4);
String s2 = buffer.getString(2);
String s3 = buffer.getString(5);
assertEquals(new String("LOVE"), s1);
assertEquals(new String("SE"), s2);
assertEquals(new String("RYUNG"), s3);
}
@Test
public void getsTest() {
Buffer buffer = initBuffer2();
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
assertEquals(3, buffer.get());
byte[] testb = new byte[7];
buffer.gets(testb, 0, 7);
int expected = 4;
for (byte b : testb) {
assertEquals(expected, b);
expected++;
}
}
@Test(expected = BufferUnderflowException.class)
public void getsTest2() {
/* Test: buffer.gets(), catch BufferUnderflowException */
Buffer buffer = initBuffer2();
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
assertEquals(3, buffer.get());
assertEquals(4, buffer.get());
assertEquals(5, buffer.get());
byte[] testb = new byte[10];
buffer.gets(testb, 0, 10);
int expected = 6;
for (byte b : testb) {
assertEquals(expected, b);
expected++;
}
}
@Test
public void getsTest3() {
Buffer buffer = initBuffer2();
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
buffer.mark();
assertEquals(3, buffer.get());
assertEquals(4, buffer.get());
assertEquals(5, buffer.get());
byte[] testb = new byte[5];
buffer.gets(testb, 0, 5);
int expected = 6;
for (byte b : testb) {
assertEquals(expected, b);
expected++;
}
buffer.reset();
testb = null;
testb = new byte[8];
buffer.gets(testb, 0, 8);
expected = 3;
for (byte b : testb) {
assertEquals(expected, b);
expected++;
}
}
@Test
public void getsTest4() {
Buffer buffer = initBuffer2();
buffer.get();
buffer.get();
buffer.get();
byte[] testb = new byte[6];
buffer.gets(testb, 0, 6);
int expected = 4;
for (byte b : testb) {
assertEquals(expected, b);
expected++;
}
}
@Test
public void getsTest5() {
/* Test: buffer.gets(), buffer.addLast(byte[]) */
Buffer buffer = new ChainBuffer();
byte[] testArray = new byte[] { 1, 2, 3, 4 };
byte[] testArray2 = new byte[] { 5, 6, 7, 8, 9 };
buffer.addLast(testArray);
buffer.addLast(testArray2);
buffer.get();
buffer.get();
buffer.get();
byte[] testb = new byte[6];
buffer.gets(testb, 0, 6);
int expected = 4;
for (byte b : testb) {
assertEquals(expected, b);
expected++;
}
byte[] testArray3 = new byte[] { 10, 11, 12 };
buffer.addLast(testArray3);
assertEquals(10, buffer.get());
assertEquals(11, buffer.get());
assertEquals(12, buffer.get());
}
@Test
public void getsTest6() {
Buffer buffer = initBuffer2();
buffer.get();
buffer.get();
buffer.get();
byte[] testb = new byte[4];
buffer.gets(testb, 0, 4);
int expected = 4;
for (byte b : testb) {
assertEquals(expected, b);
expected++;
}
assertEquals(8, buffer.get());
assertEquals(9, buffer.get());
assertEquals(10, buffer.get());
}
@Test
public void markRewindTest1() {
Buffer buffer = initBuffer2();
assertEquals(1, buffer.get());
buffer.mark();
assertEquals(2, buffer.get());
assertEquals(3, buffer.get());
assertEquals(4, buffer.get());
assertEquals(5, buffer.get());
buffer.reset();
assertEquals(2, buffer.get());
assertEquals(3, buffer.get());
}
@Test
public void markRewindTest2() {
/* Test: buffer.mark(), buffer.rewind() */
Buffer buffer = initBuffer2();
assertEquals(1, buffer.get());
buffer.mark();
assertEquals(2, buffer.get());
assertEquals(3, buffer.get());
buffer.reset();
assertEquals(2, buffer.get());
assertEquals(3, buffer.get());
}
@Test
public void markNewTest() {
Buffer buffer = initBuffer2();
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
assertEquals(3, buffer.get());
assertEquals(4, buffer.get());
assertEquals(5, buffer.get());
buffer.mark();
buffer.position(0);
assertEquals(1, buffer.get());
buffer.reset();
assertEquals(6, buffer.get());
}
@Test
public void markNewTest2() {
Buffer buffer = initBuffer2();
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
assertEquals(3, buffer.get());
assertEquals(4, buffer.get());
buffer.mark();
buffer.position(0);
assertEquals(1, buffer.get());
buffer.reset();
assertEquals(5, buffer.get());
}
@Test
public void markNewTest3() {
Buffer buffer = initBuffer2();
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
assertEquals(3, buffer.get());
assertEquals(4, buffer.get());
buffer.mark();
buffer.reset();
assertEquals(5, buffer.get());
}
@Test
public void markNewTest4() {
Buffer buffer = initBuffer2();
buffer.mark();
buffer.reset();
assertEquals(1, buffer.get());
}
@Test(expected = BufferUnderflowException.class)
public void markNewTest5() {
Buffer buffer = initBuffer2();
byte[] temp = new byte[12];
buffer.gets(temp);
buffer.mark();
buffer.reset();
assertEquals(12, buffer.get());
}
@Test
public void markNewTest6() {
Buffer buffer = initBuffer4();
byte[] temp = new byte[12];
buffer.gets(temp);
buffer.mark();
buffer.reset();
assertEquals(13, buffer.get());
}
@Test
public void markNewTest7() {
Buffer buffer = initBuffer4();
byte[] temp = new byte[18];
buffer.gets(temp);
buffer.mark();
buffer.position(0);
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
assertEquals(3, buffer.get());
buffer.reset();
assertEquals(105, buffer.get());
}
@Test(expected = InvalidMarkException.class)
public void markNewTest8() {
Buffer buffer = initBuffer2();
byte[] temp = new byte[4];
buffer.gets(temp);
buffer.position(0);
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
assertEquals(3, buffer.get());
buffer.reset();
}
@Test
public void markNewTest9() {
Buffer buffer = initBuffer2();
byte[] temp = new byte[4];
buffer.gets(temp);
buffer.position(0);
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
buffer.mark();
assertEquals(3, buffer.get());
buffer.reset();
assertEquals(3, buffer.get());
assertEquals(4, buffer.get());
assertEquals(5, buffer.get());
buffer.mark();
assertEquals(6, buffer.get());
buffer.reset();
assertEquals(6, buffer.get());
}
@Test
public void clearTest() {
Buffer buffer = initBuffer2();
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
assertEquals(3, buffer.get());
buffer.mark();
assertEquals(4, buffer.get());
assertEquals(5, buffer.get());
assertEquals(6, buffer.get());
buffer.clear();
assertEquals(1, buffer.get());
}
@Test
public void clearTest2() {
Buffer buffer = initBuffer2();
byte[] temp = new byte[12];
buffer.gets(temp);
buffer.clear();
assertEquals(1, buffer.get());
}
@Test
public void discardTest() {
Buffer buffer = initBuffer2();
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
assertEquals(3, buffer.get());
buffer.rewind();
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
assertEquals(3, buffer.get());
assertEquals(4, buffer.get());
buffer.discardReadBytes();
assertEquals(5, buffer.get());
assertEquals(6, buffer.get());
assertEquals(7, buffer.get());
buffer.rewind();
assertEquals(5, buffer.get());
assertEquals(6, buffer.get());
assertEquals(7, buffer.get());
}
@Test
public void bytesBeforeTest() {
Buffer buffer = initBuffer();
byte[] target = new byte[] { 8, 9, 10, 11, 12 };
buffer.get();
buffer.get();
int length = buffer.bytesBefore(target);
byte[] test = new byte[length];
if (length > 0) {
buffer.gets(test, 0, length);
int expected = 3;
for (byte b : test) {
assertEquals(expected, b);
expected++;
}
}
}
@Test
public void addLastTest() {
Buffer buffer = initBuffer3();
byte[] test = new byte[14];
buffer.gets(test, 0, 14);
assertEquals(101, buffer.get());
assertEquals(102, buffer.get());
assertEquals(103, buffer.get());
assertEquals(104, buffer.get());
assertEquals(105, buffer.get());
assertEquals(106, buffer.get());
assertEquals(107, buffer.get());
assertEquals(108, buffer.get());
assertEquals(109, buffer.get());
assertEquals(110, buffer.get());
assertEquals(111, buffer.get());
assertEquals(112, buffer.get());
assertEquals(21, buffer.get());
assertEquals(22, buffer.get());
assertEquals(23, buffer.get());
assertEquals(24, buffer.get());
assertEquals(25, buffer.get());
assertEquals(26, buffer.get());
assertEquals(27, buffer.get());
assertEquals(28, buffer.get());
assertEquals(29, buffer.get());
assertEquals(30, buffer.get());
assertEquals(31, buffer.get());
assertEquals(32, buffer.get());
assertEquals(33, buffer.get());
assertEquals(34, buffer.get());
assertEquals(35, buffer.get());
}
@Test
public void addLastTest2() {
Buffer buffer = initBuffer3();
byte[] test = new byte[9];
buffer.gets(test, 0, 9);
int expected = 1;
for (byte b : test) {
assertEquals(expected, b);
expected++;
}
}
@Test
public void addLastTest3() {
Buffer buffer = initBuffer3();
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
assertEquals(3, buffer.get());
assertEquals(4, buffer.get());
buffer.mark();
byte[] test = new byte[25];
buffer.gets(test, 0, 25);
assertEquals(5, test[0]);
assertEquals(6, test[1]);
assertEquals(7, test[2]);
assertEquals(8, test[3]);
assertEquals(9, test[4]);
assertEquals(10, test[5]);
assertEquals(11, test[6]);
assertEquals(12, test[7]);
assertEquals(13, test[8]);
assertEquals(14, test[9]);
assertEquals(101, test[10]);
assertEquals(102, test[11]);
assertEquals(103, test[12]);
assertEquals(104, test[13]);
assertEquals(105, test[14]);
assertEquals(106, test[15]);
assertEquals(107, test[16]);
assertEquals(108, test[17]);
assertEquals(109, test[18]);
assertEquals(110, test[19]);
assertEquals(111, test[20]);
assertEquals(112, test[21]);
assertEquals(21, test[22]);
assertEquals(22, test[23]);
assertEquals(23, test[24]);
buffer.reset();
assertEquals(5, buffer.get());
}
@Test
public void addLastTest4() {
Buffer buffer = initBuffer();
Buffer buffer2 = new ChainBuffer();
byte[] testArray6 = new byte[] { 101, 102, 103, 104 };
byte[] testArray7 = new byte[] { 105, 106, 107, 108, 109 };
byte[] testArray8 = new byte[] { 110, 111, 112 };
buffer2.addLast(testArray6);
buffer2.addLast(testArray7);
buffer2.addLast(testArray8);
Buffer buffer3 = new ChainBuffer();
byte[] testArray9 = new byte[] { 21, 22, 23 };
byte[] testArray10 = new byte[] { 24, 25 };
byte[] testArray11 = new byte[] { 26, 27, 28, 29 };
byte[] testArray12 = new byte[] { 30, 31, 32, 33, 34, 35 };
buffer3.addLast(testArray9);
buffer3.addLast(testArray10);
buffer3.addLast(testArray11);
buffer3.addLast(testArray12);
Buffer buffer4 = new ChainBuffer();
byte[] testArray13 = new byte[] { 71, 72, 73, 74, 75, 76 };
byte[] testArray14 = new byte[] { 77, 78, 79 };
buffer4.addLast(testArray13);
buffer4.addLast(testArray14);
/* put buffer2 { 104, 105, ..., 112 } */
buffer2.get();
buffer2.get();
buffer2.get();
buffer.addLast(buffer2);
/* put buffer3 { 24, 25, ..., 112 } */
buffer3.get();
buffer3.get();
buffer3.get();
buffer.addLast(buffer3);
buffer.addLast(buffer4);
byte[] t = new byte[13];
buffer.gets(t);
assertEquals(14, buffer.get());
assertEquals(101, buffer.get());
assertEquals(102, buffer.get());
assertEquals(103, buffer.get());
assertEquals(104, buffer.get());
assertEquals(105, buffer.get());
assertEquals(106, buffer.get());
assertEquals(107, buffer.get());
assertEquals(108, buffer.get());
assertEquals(109, buffer.get());
assertEquals(110, buffer.get());
assertEquals(111, buffer.get());
assertEquals(112, buffer.get());
assertEquals(21, buffer.get());
assertEquals(22, buffer.get());
assertEquals(23, buffer.get());
assertEquals(24, buffer.get());
assertEquals(25, buffer.get());
assertEquals(26, buffer.get());
assertEquals(27, buffer.get());
assertEquals(28, buffer.get());
assertEquals(29, buffer.get());
assertEquals(30, buffer.get());
assertEquals(31, buffer.get());
assertEquals(32, buffer.get());
assertEquals(33, buffer.get());
assertEquals(34, buffer.get());
assertEquals(35, buffer.get());
}
@Test
public void addLastTest5() {
Buffer buffer = initBuffer();
Buffer buffer2 = new ChainBuffer();
byte[] testArray6 = new byte[] { 101, 102, 103, 104 };
byte[] testArray7 = new byte[] { 105, 106, 107, 108, 109 };
byte[] testArray8 = new byte[] { 110, 111, 112 };
buffer2.addLast(testArray6);
buffer2.addLast(testArray7);
buffer2.addLast(testArray8);
Buffer buffer3 = new ChainBuffer();
byte[] testArray9 = new byte[] { 21, 22, 23 };
byte[] testArray10 = new byte[] { 24, 25 };
byte[] testArray11 = new byte[] { 26, 27, 28, 29 };
byte[] testArray12 = new byte[] { 30, 31, 32, 33, 34, 35 };
buffer3.addLast(testArray9);
buffer3.addLast(testArray10);
buffer3.addLast(testArray11);
buffer3.addLast(testArray12);
ChainBuffer buffer4 = new ChainBuffer();
byte[] testArray13 = new byte[] { 71, 72, 73, 74, 75, 76 };
byte[] testArray14 = new byte[] { 77, 78, 79 };
buffer4.addLast(testArray13);
buffer4.addLast(testArray14);
buffer2.get();
buffer2.get();
buffer2.get();
buffer.addLast(buffer2);
buffer3.get();
buffer3.get();
buffer3.get();
buffer3.get();
buffer3.get();
buffer3.get();
buffer3.get();
buffer3.get();
buffer3.get();
buffer3.get();
buffer3.get();
buffer3.get();
buffer3.get();
buffer3.get();
buffer3.get();
buffer.addLast(buffer3);
buffer.addLast(buffer4);
byte[] b = new byte[13];
buffer.gets(b);
assertEquals(14, buffer.get());
assertEquals(101, buffer.get());
assertEquals(102, buffer.get());
assertEquals(103, buffer.get());
assertEquals(104, buffer.get());
assertEquals(105, buffer.get());
assertEquals(106, buffer.get());
assertEquals(107, buffer.get());
assertEquals(108, buffer.get());
assertEquals(109, buffer.get());
assertEquals(110, buffer.get());
assertEquals(111, buffer.get());
assertEquals(112, buffer.get());
assertEquals(21, buffer.get());
assertEquals(22, buffer.get());
assertEquals(23, buffer.get());
assertEquals(24, buffer.get());
}
/*
* addLastLenTest() ~ addLastLenTest15() refer to
* http://mindori.egloos.com/2637204
*/
@Test
public void addLastLenTest() {
Buffer buffer = initBuffer4();
Buffer buffer4 = new ChainBuffer();
byte[] testArray13 = new byte[] { 71, 72, 73, 74, 75, 76 };
byte[] testArray14 = new byte[] { 77, 78, 79 };
byte[] testArray15 = new byte[] { 80, 81 };
byte[] testArray16 = new byte[] { 82, 83, 84, 85, 86, 87, 88, 89 };
buffer4.addLast(testArray13);
buffer4.addLast(testArray14);
buffer4.addLast(testArray15);
buffer4.addLast(testArray16);
buffer.addLast(buffer4, 5);
byte[] skip = new byte[41];
buffer.gets(skip);
int expected = 71;
int i = 0;
while (i < 5) {
assertEquals(expected, buffer.get());
expected++;
i++;
}
/* call buffer.get() throws BufferUnderflowException: OK */
}
@Test
public void addLastLenTest2() {
Buffer buffer = initBuffer4();
Buffer buffer4 = new ChainBuffer();
byte[] testArray13 = new byte[] { 71, 72, 73, 74, 75, 76 };
byte[] testArray14 = new byte[] { 77, 78, 79 };
byte[] testArray15 = new byte[] { 80, 81 };
byte[] testArray16 = new byte[] { 82, 83, 84, 85, 86, 87, 88, 89 };
buffer4.addLast(testArray13);
buffer4.addLast(testArray14);
buffer4.addLast(testArray15);
buffer4.addLast(testArray16);
buffer.addLast(buffer4, 6);
byte[] skip = new byte[41];
buffer.gets(skip);
int expected = 71;
int i = 0;
while (i < 6) {
assertEquals(expected, buffer.get());
expected++;
i++;
}
/* call buffer.get() throws BufferUnderflowException: OK */
}
@Test
public void addLastLenTest3() {
Buffer buffer = initBuffer4();
Buffer buffer4 = new ChainBuffer();
byte[] testArray13 = new byte[] { 71, 72, 73, 74, 75, 76 };
byte[] testArray14 = new byte[] { 77, 78, 79 };
byte[] testArray15 = new byte[] { 80, 81 };
byte[] testArray16 = new byte[] { 82, 83, 84, 85, 86, 87, 88, 89 };
buffer4.addLast(testArray13);
buffer4.addLast(testArray14);
buffer4.addLast(testArray15);
buffer4.addLast(testArray16);
buffer.addLast(buffer4, 8);
byte[] skip = new byte[41];
buffer.gets(skip);
int expected = 71;
int i = 0;
while (i < 8) {
assertEquals(expected, buffer.get());
expected++;
i++;
}
/* call buffer.get() throws BufferUnderflowException: OK */
}
@Test
public void addLastLenTest4() {
Buffer buffer = initBuffer4();
Buffer buffer4 = new ChainBuffer();
byte[] testArray13 = new byte[] { 71, 72, 73, 74, 75, 76 };
byte[] testArray14 = new byte[] { 77, 78, 79 };
byte[] testArray15 = new byte[] { 80, 81 };
byte[] testArray16 = new byte[] { 82, 83, 84, 85, 86, 87, 88, 89 };
buffer4.addLast(testArray13);
buffer4.addLast(testArray14);
buffer4.addLast(testArray15);
buffer4.addLast(testArray16);
buffer.addLast(buffer4, 9);
byte[] skip = new byte[41];
buffer.gets(skip);
int expected = 71;
int i = 0;
while (i < 9) {
assertEquals(expected, buffer.get());
expected++;
i++;
}
/* call buffer.get() throws BufferUnderflowException: OK */
}
@Test
public void addLastLenTest5() {
Buffer buffer = initBuffer4();
Buffer buffer4 = new ChainBuffer();
byte[] testArray13 = new byte[] { 71, 72, 73, 74, 75, 76 };
byte[] testArray14 = new byte[] { 77, 78, 79 };
byte[] testArray15 = new byte[] { 80, 81 };
byte[] testArray16 = new byte[] { 82, 83, 84, 85, 86, 87, 88, 89 };
buffer4.addLast(testArray13);
buffer4.addLast(testArray14);
buffer4.addLast(testArray15);
buffer4.addLast(testArray16);
buffer.addLast(buffer4, 11);
byte[] skip = new byte[41];
buffer.gets(skip);
int expected = 71;
int i = 0;
while (i < 11) {
assertEquals(expected, buffer.get());
expected++;
i++;
}
/* call buffer.get() throws BufferUnderflowException: OK */
}
@Test
public void addLastLenTest6() {
Buffer buffer = initBuffer4();
Buffer buffer4 = new ChainBuffer();
byte[] testArray13 = new byte[] { 71, 72, 73, 74, 75, 76 };
byte[] testArray14 = new byte[] { 77, 78, 79 };
byte[] testArray15 = new byte[] { 80, 81 };
byte[] testArray16 = new byte[] { 82, 83, 84, 85, 86, 87, 88, 89 };
buffer4.addLast(testArray13);
buffer4.addLast(testArray14);
buffer4.addLast(testArray15);
buffer4.addLast(testArray16);
buffer.addLast(buffer4, 19);
byte[] skip = new byte[41];
buffer.gets(skip);
int expected = 71;
int i = 0;
while (i < 19) {
assertEquals(expected, buffer.get());
expected++;
i++;
}
/* call buffer.get() throws BufferUnderflowException: OK */
}
@Test
public void addLastLenTest7() {
Buffer buffer = initBuffer4();
Buffer buffer4 = new ChainBuffer();
byte[] testArray13 = new byte[] { 71, 72, 73, 74, 75, 76 };
byte[] testArray14 = new byte[] { 77, 78, 79 };
byte[] testArray15 = new byte[] { 80, 81 };
byte[] testArray16 = new byte[] { 82, 83, 84, 85, 86, 87, 88, 89 };
buffer4.addLast(testArray13);
buffer4.addLast(testArray14);
buffer4.addLast(testArray15);
buffer4.addLast(testArray16);
buffer.addLast(buffer4, 20);
byte[] skip = new byte[35];
buffer.gets(skip);
/* call buffer.get() throws BufferUnderflowException: OK */
}
@Test
public void addLastLenTest8() {
Buffer buffer = initBuffer4();
Buffer buffer4 = new ChainBuffer();
byte[] testArray13 = new byte[] { 71, 72, 73, 74, 75, 76 };
byte[] testArray14 = new byte[] { 77, 78, 79 };
byte[] testArray15 = new byte[] { 80, 81 };
byte[] testArray16 = new byte[] { 82, 83, 84, 85, 86, 87, 88, 89 };
buffer4.addLast(testArray13);
buffer4.addLast(testArray14);
buffer4.addLast(testArray15);
buffer4.addLast(testArray16);
buffer4.get();
buffer4.get();
buffer.addLast(buffer4, 3);
byte[] skip = new byte[41];
buffer.gets(skip);
int expected = 73;
int i = 0;
while (i < 3) {
assertEquals(expected, buffer.get());
expected++;
i++;
}
/* call buffer.get() throws BufferUnderflowException: OK */
}
@Test
public void addLastLenTest9() {
Buffer buffer = initBuffer4();
Buffer buffer4 = new ChainBuffer();
byte[] testArray13 = new byte[] { 71, 72, 73, 74, 75, 76 };
byte[] testArray14 = new byte[] { 77, 78, 79 };
byte[] testArray15 = new byte[] { 80, 81 };
byte[] testArray16 = new byte[] { 82, 83, 84, 85, 86, 87, 88, 89 };
buffer4.addLast(testArray13);
buffer4.addLast(testArray14);
buffer4.addLast(testArray15);
buffer4.addLast(testArray16);
buffer4.get();
buffer4.get();
buffer.addLast(buffer4, 4);
byte[] skip = new byte[41];
buffer.gets(skip);
int expected = 73;
int i = 0;
while (i < 4) {
assertEquals(expected, buffer.get());
expected++;
i++;
}
/* call buffer.get() throws BufferUnderflowException: OK */
}
@Test
public void addLastLenTest10() {
Buffer buffer = initBuffer4();
Buffer buffer4 = new ChainBuffer();
byte[] testArray13 = new byte[] { 71, 72, 73, 74, 75, 76 };
byte[] testArray14 = new byte[] { 77, 78, 79 };
byte[] testArray15 = new byte[] { 80, 81 };
byte[] testArray16 = new byte[] { 82, 83, 84, 85, 86, 87, 88, 89 };
buffer4.addLast(testArray13);
buffer4.addLast(testArray14);
buffer4.addLast(testArray15);
buffer4.addLast(testArray16);
buffer4.get();
buffer4.get();
buffer.addLast(buffer4, 6);
byte[] skip = new byte[41];
buffer.gets(skip);
int expected = 73;
int i = 0;
while (i < 6) {
assertEquals(expected, buffer.get());
expected++;
i++;
}
/* call buffer.get() throws BufferUnderflowException: OK */
}
@Test
public void addLastLenTest11() {
Buffer buffer = initBuffer4();
Buffer buffer4 = new ChainBuffer();
byte[] testArray13 = new byte[] { 71, 72, 73, 74, 75, 76 };
byte[] testArray14 = new byte[] { 77, 78, 79 };
byte[] testArray15 = new byte[] { 80, 81 };
byte[] testArray16 = new byte[] { 82, 83, 84, 85, 86, 87, 88, 89 };
buffer4.addLast(testArray13);
buffer4.addLast(testArray14);
buffer4.addLast(testArray15);
buffer4.addLast(testArray16);
buffer4.get();
buffer4.get();
buffer.addLast(buffer4, 7);
byte[] skip = new byte[41];
buffer.gets(skip);
int expected = 73;
int i = 0;
while (i < 7) {
assertEquals(expected, buffer.get());
expected++;
i++;
}
/* call buffer.get() throws BufferUnderflowException: OK */
}
@Test
public void addLastLenTest12() {
Buffer buffer = initBuffer4();
Buffer buffer4 = new ChainBuffer();
byte[] testArray13 = new byte[] { 71, 72, 73, 74, 75, 76 };
byte[] testArray14 = new byte[] { 77, 78, 79 };
byte[] testArray15 = new byte[] { 80, 81 };
byte[] testArray16 = new byte[] { 82, 83, 84, 85, 86, 87, 88, 89 };
buffer4.addLast(testArray13);
buffer4.addLast(testArray14);
buffer4.addLast(testArray15);
buffer4.addLast(testArray16);
buffer4.get();
buffer4.get();
buffer.addLast(buffer4, 17);
byte[] skip = new byte[41];
buffer.gets(skip);
int expected = 73;
int i = 0;
while (i < 17) {
assertEquals(expected, buffer.get());
expected++;
i++;
}
/* call buffer.get() throws BufferUnderflowException: OK */
}
@Test
public void addLastLenTest13() {
Buffer buffer = initBuffer4();
Buffer buffer4 = new ChainBuffer();
byte[] testArray13 = new byte[] { 71, 72, 73, 74, 75, 76 };
byte[] testArray14 = new byte[] { 77, 78, 79 };
byte[] testArray15 = new byte[] { 80, 81 };
byte[] testArray16 = new byte[] { 82, 83, 84, 85, 86, 87, 88, 89 };
buffer4.addLast(testArray13);
buffer4.addLast(testArray14);
buffer4.addLast(testArray15);
buffer4.addLast(testArray16);
buffer4.get();
buffer4.get();
buffer.addLast(buffer4, 18);
byte[] skip = new byte[35];
buffer.gets(skip);
/* call buffer.get() throws BufferUnderflowException: OK */
}
@Test
public void addLastLenTest14() {
Buffer buffer = initBuffer4();
Buffer buffer4 = new ChainBuffer();
byte[] testArray13 = new byte[] { 71, 72, 73, 74, 75, 76 };
byte[] testArray14 = new byte[] { 77, 78, 79 };
byte[] testArray15 = new byte[] { 80, 81 };
byte[] testArray16 = new byte[] { 82, 83, 84, 85, 86, 87, 88, 89 };
buffer4.addLast(testArray13);
buffer4.addLast(testArray14);
buffer4.addLast(testArray15);
buffer4.addLast(testArray16);
byte[] skip = new byte[35];
buffer.gets(skip);
byte[] skip2 = new byte[13];
buffer4.gets(skip2);
buffer.addLast(buffer4, 3);
int expected = 30;
int i = 0;
while (i < 3) {
assertEquals(expected, buffer.get());
expected++;
i++;
}
/* call buffer.get() throws BufferUnderflowException: OK */
}
@Test
public void addLastLenTest15() {
Buffer buffer = initBuffer4();
Buffer buffer4 = new ChainBuffer();
byte[] testArray13 = new byte[] { 71, 72, 73, 74, 75, 76 };
byte[] testArray14 = new byte[] { 77, 78, 79 };
byte[] testArray15 = new byte[] { 80, 81 };
byte[] testArray16 = new byte[] { 82, 83, 84, 85, 86, 87, 88, 89 };
buffer4.addLast(testArray13);
buffer4.addLast(testArray14);
buffer4.addLast(testArray15);
buffer4.addLast(testArray16);
byte[] skip = new byte[35];
buffer.gets(skip);
byte[] skip2 = new byte[13];
buffer4.gets(skip2);
buffer.addLast(buffer4, 6);
int expected = 30;
int i = 0;
while (i < 6) {
assertEquals(expected, buffer.get());
expected++;
i++;
}
/* call buffer.get() throws BufferUnderflowException: OK */
}
@Test
public void moveTest() {
Buffer buffer = initBuffer();
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
buffer.skip(8);
assertEquals(11, buffer.get());
assertEquals(12, buffer.get());
}
@Test
public void moveTest2() {
Buffer buffer = initBuffer();
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
assertEquals(3, buffer.get());
buffer.skip(8);
assertEquals(12, buffer.get());
assertEquals(13, buffer.get());
}
@Test
public void moveTest3() {
Buffer buffer = initBuffer();
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
assertEquals(null, buffer.skip(13));
assertEquals(3, buffer.get());
assertEquals(4, buffer.get());
}
@Test
public void moveTest4() {
Buffer buffer = initBuffer();
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
assertEquals(3, buffer.get());
buffer.skip(1);
assertEquals(5, buffer.get());
assertEquals(6, buffer.get());
assertEquals(7, buffer.get());
buffer.rewind();
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
}
@Test
public void unsignedShortTest() {
Buffer buffer = new ChainBuffer();
buffer.addLast(new byte[] { (byte) 0xfb, 0x50 });
int value = buffer.getUnsignedShort();
assertEquals(64336, value);
}
@Test
public void flipTest() {
Buffer buffer = new ChainBuffer();
byte[] testArray = new byte[] { 1, 2 };
byte[] testArray2 = new byte[] { 3, 4, 5 };
byte[] testArray3 = new byte[] { 6, 7, 8, 9 };
byte[] testArray4 = new byte[] { 10, 11 };
byte[] testArray5 = new byte[] { 12, 13, 14 };
buffer.addLast(testArray);
buffer.addLast(testArray2);
buffer.addLast(testArray3);
buffer.addLast(testArray4);
buffer.addLast(testArray5);
buffer.get();
buffer.get();
buffer.get();
buffer.flip();
assertEquals(3, buffer.readableBytes());
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
assertEquals(3, buffer.get());
}
@Test
public void flipTest2() {
Buffer buffer = new ChainBuffer();
byte[] testArray = new byte[] { 1, 2 };
byte[] testArray2 = new byte[] { 3, 4, 5 };
byte[] testArray3 = new byte[] { 6, 7, 8, 9 };
byte[] testArray4 = new byte[] { 10, 11 };
byte[] testArray5 = new byte[] { 12, 13, 14 };
buffer.addLast(testArray);
buffer.addLast(testArray2);
buffer.addLast(testArray3);
buffer.addLast(testArray4);
buffer.addLast(testArray5);
buffer.get();
buffer.get();
buffer.flip();
assertEquals(2, buffer.readableBytes());
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
}
@Test
public void flipTest3() {
Buffer buffer = new ChainBuffer();
byte[] testArray = new byte[] { 1, 2 };
byte[] testArray2 = new byte[] { 3, 4, 5 };
byte[] testArray3 = new byte[] { 6, 7, 8, 9 };
byte[] testArray4 = new byte[] { 10, 11 };
byte[] testArray5 = new byte[] { 12, 13, 14 };
buffer.addLast(testArray);
buffer.addLast(testArray2);
buffer.addLast(testArray3);
buffer.addLast(testArray4);
buffer.addLast(testArray5);
buffer.get();
buffer.flip();
assertEquals(1, buffer.readableBytes());
assertEquals(1, buffer.get());
}
@Test
public void flipTest4() {
Buffer buffer = new ChainBuffer();
byte[] testArray = new byte[] { 1, 2 };
byte[] testArray2 = new byte[] { 3, 4, 5 };
byte[] testArray3 = new byte[] { 6, 7, 8, 9 };
byte[] testArray4 = new byte[] { 10, 11 };
byte[] testArray5 = new byte[] { 12, 13, 14 };
buffer.addLast(testArray);
buffer.addLast(testArray2);
buffer.addLast(testArray3);
buffer.addLast(testArray4);
buffer.addLast(testArray5);
buffer.flip();
assertEquals(0, buffer.readableBytes());
}
@Test
public void flipTest5() {
Buffer buffer = new ChainBuffer();
byte[] testArray = new byte[] { 1, 2 };
byte[] testArray2 = new byte[] { 3, 4, 5 };
byte[] testArray3 = new byte[] { 6, 7, 8, 9 };
byte[] testArray4 = new byte[] { 10, 11 };
byte[] testArray5 = new byte[] { 12, 13, 14 };
buffer.addLast(testArray);
buffer.addLast(testArray2);
buffer.addLast(testArray3);
buffer.addLast(testArray4);
buffer.addLast(testArray5);
byte[] b = new byte[14];
buffer.gets(b);
buffer.flip();
assertEquals(14, buffer.readableBytes());
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
}
@Test
public void flipTest6() {
Buffer buffer = new ChainBuffer();
byte[] testArray = new byte[] { 1, 2 };
byte[] testArray2 = new byte[] { 3, 4, 5 };
byte[] testArray3 = new byte[] { 6, 7, 8, 9 };
byte[] testArray4 = new byte[] { 10, 11 };
byte[] testArray5 = new byte[] { 12, 13, 14 };
buffer.addLast(testArray);
buffer.addLast(testArray2);
buffer.addLast(testArray3);
buffer.addLast(testArray4);
buffer.addLast(testArray5);
byte[] b = new byte[13];
buffer.gets(b);
buffer.flip();
assertEquals(13, buffer.readableBytes());
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
}
@Test
public void flipTest7() {
Buffer buffer = new ChainBuffer();
byte[] testArray = new byte[] { 1, 2 };
byte[] testArray2 = new byte[] { 3, 4, 5 };
byte[] testArray3 = new byte[] { 6, 7, 8, 9 };
byte[] testArray4 = new byte[] { 10, 11 };
byte[] testArray5 = new byte[] { 12, 13, 14 };
buffer.addLast(testArray);
buffer.addLast(testArray2);
buffer.addLast(testArray3);
buffer.addLast(testArray4);
buffer.addLast(testArray5);
Buffer buffer2 = new ChainBuffer();
byte[] testArray6 = new byte[] { 101, 102, 103, 104 };
byte[] testArray7 = new byte[] { 105, 106, 107, 108, 109 };
byte[] testArray8 = new byte[] { 110, 111, 112 };
buffer2.addLast(testArray6);
buffer2.addLast(testArray7);
buffer2.addLast(testArray8);
buffer.addLast(buffer2);
byte[] b = new byte[17];
buffer.gets(b);
buffer.flip();
assertEquals(17, buffer.readableBytes());
assertEquals(1, buffer.get());
assertEquals(2, buffer.get());
buffer.skip(10);
assertEquals(13, buffer.get());
assertEquals(14, buffer.get());
assertEquals(101, buffer.get());
}
@Test
public void flipTest8() {
Buffer buffer = new ChainBuffer();
byte[] testArray = new byte[] { 1, 2 };
byte[] testArray2 = new byte[] { 3, 4, 5 };
byte[] testArray3 = new byte[] { 6, 7, 8, 9 };
byte[] testArray4 = new byte[] { 10, 11 };
byte[] testArray5 = new byte[] { 12, 13, 14 };
buffer.addLast(testArray);
buffer.addLast(testArray2);
buffer.addLast(testArray3);
buffer.addLast(testArray4);
buffer.addLast(testArray5);
Buffer buffer2 = new ChainBuffer();
byte[] testArray6 = new byte[] { 101, 102, 103, 104 };
byte[] testArray7 = new byte[] { 105, 106, 107, 108, 109 };
byte[] testArray8 = new byte[] { 110, 111, 112 };
buffer2.addLast(testArray6);
buffer2.addLast(testArray7);
buffer2.addLast(testArray8);
buffer.addLast(buffer2);
byte[] b = new byte[26];
buffer.gets(b);
buffer.flip();
assertEquals(26, buffer.readableBytes());
}
@Test
public void flipTest9() {
Buffer buffer = new ChainBuffer();
byte[] testArray = new byte[] { 1, 2 };
byte[] testArray2 = new byte[] { 3, 4, 5 };
byte[] testArray3 = new byte[] { 6, 7, 8, 9 };
byte[] testArray4 = new byte[] { 10, 11 };
byte[] testArray5 = new byte[] { 12, 13, 14 };
buffer.addLast(testArray);
buffer.addLast(testArray2);
buffer.addLast(testArray3);
buffer.addLast(testArray4);
buffer.addLast(testArray5);
Buffer buffer2 = new ChainBuffer();
byte[] testArray6 = new byte[] { 101, 102, 103, 104 };
byte[] testArray7 = new byte[] { 105, 106, 107, 108, 109 };
byte[] testArray8 = new byte[] { 110, 111, 112 };
buffer2.addLast(testArray6);
buffer2.addLast(testArray7);
buffer2.addLast(testArray8);
buffer.addLast(buffer2);
byte[] b = new byte[14];
buffer.gets(b);
buffer.flip();
assertEquals(14, buffer.readableBytes());
assertEquals(1, buffer.get());
}
@Test
public void flipTest10() {
Buffer buffer = new ChainBuffer();
byte[] testArray = new byte[] { 1, 2 };
byte[] testArray2 = new byte[] { 3, 4, 5 };
byte[] testArray3 = new byte[] { 6, 7, 8, 9 };
byte[] testArray4 = new byte[] { 10, 11 };
byte[] testArray5 = new byte[] { 12, 13, 14 };
buffer.addLast(testArray);
buffer.addLast(testArray2);
buffer.addLast(testArray3);
buffer.addLast(testArray4);
buffer.addLast(testArray5);
Buffer buffer2 = new ChainBuffer();
byte[] testArray6 = new byte[] { 101, 102, 103, 104 };
byte[] testArray7 = new byte[] { 105, 106, 107, 108, 109 };
byte[] testArray8 = new byte[] { 110, 111, 112 };
buffer2.addLast(testArray6);
buffer2.addLast(testArray7);
buffer2.addLast(testArray8);
buffer.addLast(buffer2);
byte[] b = new byte[23];
buffer.gets(b);
buffer.flip();
assertEquals(23, buffer.readableBytes());
assertEquals(1, buffer.get());
}
@Test
public void flipTest11() {
Buffer buffer = new ChainBuffer();
byte[] testArray = new byte[] { 1, 2 };
byte[] testArray2 = new byte[] { 3, 4, 5 };
byte[] testArray3 = new byte[] { 6, 7, 8, 9 };
byte[] testArray4 = new byte[] { 10, 11 };
byte[] testArray5 = new byte[] { 12, 13, 14 };
buffer.addLast(testArray);
buffer.addLast(testArray2);
buffer.addLast(testArray3);
buffer.addLast(testArray4);
buffer.addLast(testArray5);
Buffer buffer2 = new ChainBuffer();
byte[] testArray6 = new byte[] { 101, 102, 103, 104 };
byte[] testArray7 = new byte[] { 105, 106, 107, 108, 109 };
byte[] testArray8 = new byte[] { 110, 111, 112 };
buffer2.addLast(testArray6);
buffer2.addLast(testArray7);
buffer2.addLast(testArray8);
buffer.addLast(buffer2);
byte[] b = new byte[22];
buffer.gets(b);
buffer.flip();
assertEquals(22, buffer.readableBytes());
assertEquals(1, buffer.get());
}
@Test
public void flipTest12() {
Buffer buffer = new ChainBuffer();
byte[] testArray = new byte[] { 1, 2 };
byte[] testArray2 = new byte[] { 3, 4, 5 };
byte[] testArray3 = new byte[] { 6, 7, 8, 9 };
byte[] testArray4 = new byte[] { 10, 11 };
byte[] testArray5 = new byte[] { 12, 13, 14 };
buffer.addLast(testArray);
buffer.addLast(testArray2);
buffer.addLast(testArray3);
buffer.addLast(testArray4);
buffer.addLast(testArray5);
Buffer buffer2 = new ChainBuffer();
byte[] testArray6 = new byte[] { 101, 102, 103, 104 };
byte[] testArray7 = new byte[] { 105, 106, 107, 108, 109 };
byte[] testArray8 = new byte[] { 110, 111, 112 };
buffer2.addLast(testArray6);
buffer2.addLast(testArray7);
buffer2.addLast(testArray8);
buffer.addLast(buffer2);
buffer.get();
buffer.get();
buffer.get();
buffer.get();
buffer.discardReadBytes();
buffer.skip(22);
buffer.flip();
assertEquals(22, buffer.readableBytes());
assertEquals(5, buffer.get());
}
}