package com.peterhi.obsolete;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import java.io.EOFException;
import java.math.BigInteger;
import org.junit.Test;
import com.peterhi.obsolete.Data;
import com.peterhi.obsolete.InsufficientBufferException;
import com.peterhi.obsolete.RT;
public final class DataTest {
@Test
public void pCtor_void() throws Exception {
try {
Data data = new Data();
assertEquals(0, data.readable());
assertEquals(0, data.written());
assertEquals(512, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(0, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
} finally {
}
}
@Test
public void fCtor_void() throws Exception {
}
@Test
public void pCtor_int() throws Exception {
try {
Data data = new Data(1);
assertEquals(0, data.readable());
assertEquals(0, data.written());
assertEquals(1, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(0, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
} finally {
}
try {
Data data = new Data(0);
assertEquals(0, data.readable());
assertEquals(0, data.written());
assertEquals(0, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(0, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
} finally {
}
}
@Test
public void fCtor_int() throws Exception {
try {
Data data = new Data(-1);
fail();
} catch (IllegalArgumentException ex) {
} finally {
}
}
@Test
public void pCtor_byteArray() throws Exception {
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer);
assertEquals(400, data.written());
assertEquals(400, data.readable());
assertEquals(50, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(400, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
} finally {
}
try {
byte[] buffer = new byte[0];
Data data = new Data(buffer);
assertEquals(0, data.written());
assertEquals(0, data.readable());
assertEquals(0, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(0, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
} finally {
}
}
@Test
public void fCtor_byteArray() throws Exception {
try {
Data data = new Data(null);
fail();
} catch (NullPointerException ex) {
} finally {
}
}
@Test
public void pCtor_byteArray_int_int() throws Exception {
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer, 0, buffer.length);
assertEquals(400, data.written());
assertEquals(400, data.readable());
assertEquals(50, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(400, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer, 15, 20);
assertEquals(160, data.written());
assertEquals(160, data.readable());
assertEquals(20, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(160, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer, 25, 0);
assertEquals(0, data.written());
assertEquals(0, data.readable());
assertEquals(0, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(0, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
} finally {
}
try {
byte[] buffer = new byte[0];
Data data = new Data(buffer, 0, buffer.length);
assertEquals(0, data.written());
assertEquals(0, data.readable());
assertEquals(0, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(0, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
} finally {
}
}
@Test
public void fCtor_byteArray_int_int() throws Exception {
try {
Data data = new Data(null, 0, 0);
fail();
} catch (NullPointerException ex) {
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer, -1, 0);
fail();
} catch (IllegalArgumentException ex) {
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer, 0, -1);
fail();
} catch (IllegalArgumentException ex) {
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer, 40, 11);
fail();
} catch (IndexOutOfBoundsException ex) {
} finally {
}
}
@Test
public void pCtor_byteArray_long_long_boolean() throws Exception {
try {
byte[] buffer = new byte[] {
Integer.valueOf("01010101", 2).byteValue(),
Integer.valueOf("10101010", 2).byteValue()
};
Data data = new Data(buffer, 0, 8, true);
assertEquals(8, data.written());
assertEquals(8, data.readable());
assertEquals(1, data.debug_GetBuffer().length);
assertEquals(Integer.valueOf("01010101", 2).byteValue(), data.debug_GetBuffer()[0]);
assertEquals(0, data.debug_GetRead());
assertEquals(8, data.debug_GetWrite());
} finally {
}
try {
byte[] buffer = new byte[] {
Integer.valueOf("01010101", 2).byteValue(),
Integer.valueOf("10101010", 2).byteValue()
};
Data data = new Data(buffer, 0, 8, false);
assertEquals(8, data.written());
assertEquals(8, data.readable());
assertEquals(1, data.debug_GetBuffer().length);
assertEquals(Integer.valueOf("01010101", 2).byteValue(), data.debug_GetBuffer()[0]);
assertEquals(0, data.debug_GetRead());
assertEquals(8, data.debug_GetWrite());
} finally {
}
try {
byte[] buffer = new byte[] {
Integer.valueOf("01010101", 2).byteValue(),
Integer.valueOf("10101010", 2).byteValue()
};
Data data = new Data(buffer, 3, 7, true);
assertEquals(7, data.written());
assertEquals(7, data.readable());
assertEquals(1, data.debug_GetBuffer().length);
assertEquals(Integer.valueOf("1001010", 2).byteValue(), data.debug_GetBuffer()[0]);
assertEquals(0, data.debug_GetRead());
assertEquals(7, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
} finally {
}
try {
byte[] buffer = new byte[] {
Integer.valueOf("01010101", 2).byteValue(),
Integer.valueOf("10101010", 2).byteValue()
};
Data data = new Data(buffer, 3, 7, false);
assertEquals(10, data.written());
assertEquals(10, data.readable());
assertEquals(2, data.debug_GetBuffer().length);
assertEquals(Integer.valueOf("01010000", 2).byteValue(), data.debug_GetBuffer()[0]);
assertEquals(Integer.valueOf("00000010", 2).byteValue(), data.debug_GetBuffer()[1]);
assertEquals(0, data.debug_GetRead());
assertEquals(10, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer, 0, 0, true);
assertEquals(0, data.written());
assertEquals(0, data.readable());
assertEquals(0, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(0, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer, 0, 0, false);
assertEquals(0, data.written());
assertEquals(0, data.readable());
assertEquals(0, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(0, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
} finally {
}
try {
byte[] buffer = new byte[0];
Data data = new Data(buffer, 0, buffer.length, true);
assertEquals(0, data.written());
assertEquals(0, data.readable());
assertEquals(0, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(0, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
} finally {
}
try {
byte[] buffer = new byte[0];
Data data = new Data(buffer, 0, buffer.length, false);
assertEquals(0, data.written());
assertEquals(0, data.readable());
assertEquals(0, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(0, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
} finally {
}
}
@Test
public void fCtor_byteArray_long_long_boolean() throws Exception {
try {
Data data = new Data(null, 0, 0, true);
fail();
} catch (NullPointerException ex) {
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer, -1, 0, true);
fail();
} catch (IllegalArgumentException ex) {
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer, 0, -1, true);
fail();
} catch (IllegalArgumentException ex) {
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer, 350, 51, true);
fail();
} catch (IndexOutOfBoundsException ex) {
} finally {
}
}
@Test
public void pReadable_void() throws Exception {
try {
Data data = new Data();
assertEquals(0, data.readable());
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer);
assertEquals(400, data.readable());
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer, 15, 20);
assertEquals(160, data.readable());
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer, 300, 50, true);
assertEquals(50, data.readable());
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer, 300, 50, false);
assertEquals(54, data.readable());
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer);
data.read();
assertEquals(399, data.readable());
} finally {
}
}
@Test
public void fReadable_void() throws Exception {
}
@Test
public void pWritten_void() throws Exception {
try {
Data data = new Data();
assertEquals(0, data.written());
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer);
assertEquals(400, data.written());
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer, 15, 20);
assertEquals(160, data.written());
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer, 300, 50, true);
assertEquals(50, data.written());
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer, 300, 50, false);
assertEquals(54, data.written());
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer);
data.read();
assertEquals(400, data.written());
} finally {
}
}
@Test
public void fWritten_void() throws Exception {
}
@Test
public void pPeek_void() throws Exception {
try {
Data data = new Data(new byte[] {
Integer.valueOf("01010101", 2).byteValue()
});
assertEquals(0, data.debug_GetRead());
int a = data.peek();
assertEquals(0, data.debug_GetRead());
int b = data.read();
assertEquals(1, data.debug_GetRead());
assertEquals(1, a);
assertEquals(1, b);
assertEquals(7, data.readable());
data.skip(7);
assertEquals(-1, data.peek());
} finally {
}
}
@Test
public void fPeek_void() throws Exception {
}
@Test
public void pPeek2_void() throws Exception {
try {
Data data = new Data(new byte[] {
Integer.valueOf("01010101", 2).byteValue()
});
assertEquals(0, data.debug_GetRead());
boolean a = data.peek2();
assertEquals(0, data.debug_GetRead());
boolean b = data.read2();
assertEquals(1, data.debug_GetRead());
assertEquals(true, a);
assertEquals(true, b);
assertEquals(7, data.readable());
data.skip(7);
assertEquals(0, data.readable());
} finally {
}
}
@Test
public void fPeek2_void() throws Exception {
try {
Data data = new Data(0);
data.peek2();
fail();
} catch (EOFException ex) {
} finally {
}
}
@Test
public void pPeek_int_boolean() throws Exception {
try {
Data data = new Data(new byte[] {
Integer.valueOf("00011111", 2).byteValue(),
Integer.valueOf("10001111", 2).byteValue(),
Integer.valueOf("11111010", 2).byteValue(),
Integer.valueOf("10010110", 2).byteValue()
});
assertEquals(0, data.debug_GetRead());
BigInteger a = data.peek(32, false);
assertEquals(0, data.debug_GetRead());
BigInteger b = data.read(32, false);
assertEquals(32, data.debug_GetRead());
assertEquals(a, b);
assertEquals(0, data.readable());
} finally {
}
}
@Test
public void fPeek_int_boolean() throws Exception {
try {
Data data = new Data(0);
data.peek(32, false);
} catch (EOFException ex) {
} finally {
}
try {
Data data = new Data(new byte[] {
Integer.valueOf("01010101", 2).byteValue()
});
data.peek(9, false);
fail();
} catch (InsufficientBufferException ex) {
} finally {
}
}
@Test
public void pRead_void() throws Exception {
try {
byte[] buffer = new byte[] {
Integer.valueOf("01010101", 2).byteValue(),
Integer.valueOf("10101010", 2).byteValue()
};
Data data = new Data(buffer);
assertEquals(2, data.debug_GetBuffer().length);
assertEquals(16, data.debug_GetWrite());
assertEquals(16, data.written());
assertEquals(16, data.readable());
for (int i = 0; i < 8; i++) {
assertEquals(1 - i % 2, data.read());
}
assertEquals(8, data.debug_GetRead());
assertEquals(8, data.readable());
for (int i = 0; i < 8; i++) {
assertEquals(i % 2, data.read());
}
assertEquals(16, data.debug_GetRead());
assertEquals(16, data.debug_GetWrite());
assertEquals(0, data.readable());
} finally {
}
}
@Test
public void fRead_void() throws Exception {
try {
byte[] buffer = new byte[] {
Integer.valueOf("01010101", 2).byteValue()
};
Data data = new Data(buffer, 0, 1, true);
assertEquals(1, data.read());
assertEquals(RT.EOF, data.read());
} finally {
}
}
@Test
public void pRead2_void() throws Exception {
try {
byte[] buffer = new byte[] {
Integer.valueOf("01010101", 2).byteValue(),
Integer.valueOf("10101010", 2).byteValue()
};
Data data = new Data(buffer);
assertEquals(2, data.debug_GetBuffer().length);
assertEquals(16, data.written());
assertEquals(16, data.readable());
for (int i = 0; i < 8; i++) {
if (i % 2 == 0) {
assertEquals(true, data.read2());
} else {
assertEquals(false, data.read2());
}
}
assertEquals(8, data.debug_GetRead());
assertEquals(8, data.readable());
for (int i = 0; i < 8; i++) {
if (i % 2 == 0) {
assertEquals(false, data.read2());
} else {
assertEquals(true, data.read2());
}
}
assertEquals(16, data.debug_GetRead());
assertEquals(16, data.debug_GetWrite());
assertEquals(0, data.readable());
} finally {
}
}
@Test
public void fRead2_void() throws Exception {
try {
byte[] buffer = new byte[] {
Integer.valueOf("01010101", 2).byteValue()
};
Data data = new Data(buffer, 0, 1, true);
assertEquals(true, data.read2());
data.read2();
fail();
} catch (EOFException ex) {
}
}
@Test
public void pWrite_int() throws Exception {
try {
Data data = new Data();
assertEquals(0, data.written());
assertEquals(0, data.readable());
assertEquals(512, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(0, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
for (int i = 0; i < 8; i++) {
data.write(1 - i % 2);
}
assertEquals(8, data.written());
assertEquals(8, data.readable());
assertEquals(0, data.debug_GetRead());
assertEquals(8, data.debug_GetWrite());
for (int i = 0; i < 8; i++) {
data.write(i % 2);
}
assertEquals(16, data.written());
assertEquals(16, data.readable());
assertEquals(0, data.debug_GetRead());
assertEquals(16, data.debug_GetWrite());
assertEquals(Integer.valueOf("01010101", 2).byteValue(), data.debug_GetBuffer()[0]);
assertEquals(Integer.valueOf("10101010", 2).byteValue(), data.debug_GetBuffer()[1]);
data.write(-1);
data.write(8349543);
assertEquals(Integer.valueOf("00000011", 2).byteValue(), data.debug_GetBuffer()[2]);
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer);
assertEquals(400, data.written());
assertEquals(400, data.readable());
assertEquals(50, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(400, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
for (int i = 0; i < 8; i++) {
data.write(1 - i % 2);
}
assertEquals(178, data.debug_GetBuffer().length);
assertEquals(408, data.written());
assertEquals(408, data.readable());
assertEquals(0, data.debug_GetRead());
assertEquals(408, data.debug_GetWrite());
for (int i = 0; i < 8; i++) {
data.write(i % 2);
}
assertEquals(178, data.debug_GetBuffer().length);
assertEquals(416, data.written());
assertEquals(416, data.readable());
assertEquals(0, data.debug_GetRead());
assertEquals(416, data.debug_GetWrite());
} finally {
}
}
@Test
public void fWrite_int() throws Exception {
}
@Test
public void pWrite2_boolean() throws Exception {
try {
Data data = new Data();
assertEquals(0, data.written());
assertEquals(0, data.readable());
assertEquals(512, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(0, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
for (int i = 0; i < 8; i++) {
data.write2(i % 2 == 0);
}
assertEquals(8, data.written());
assertEquals(8, data.readable());
assertEquals(0, data.debug_GetRead());
assertEquals(8, data.debug_GetWrite());
for (int i = 0; i < 8; i++) {
data.write2(i % 2 != 0);
}
assertEquals(16, data.written());
assertEquals(16, data.readable());
assertEquals(0, data.debug_GetRead());
assertEquals(16, data.debug_GetWrite());
assertEquals(Integer.valueOf("01010101", 2).byteValue(), data.debug_GetBuffer()[0]);
assertEquals(Integer.valueOf("10101010", 2).byteValue(), data.debug_GetBuffer()[1]);
} finally {
}
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer);
assertEquals(400, data.written());
assertEquals(400, data.readable());
assertEquals(50, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(400, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
for (int i = 0; i < 8; i++) {
data.write2(i % 2 == 0);
}
assertEquals(178, data.debug_GetBuffer().length);
assertEquals(408, data.written());
assertEquals(408, data.readable());
assertEquals(0, data.debug_GetRead());
assertEquals(408, data.debug_GetWrite());
for (int i = 0; i < 8; i++) {
data.write2(i % 2 != 0);
}
assertEquals(178, data.debug_GetBuffer().length);
assertEquals(416, data.written());
assertEquals(416, data.readable());
assertEquals(0, data.debug_GetRead());
assertEquals(416, data.debug_GetWrite());
} finally {
}
}
@Test
public void fWrite2_boolean() throws Exception {
}
@Test
public void pRead_int_boolean() throws Exception {
try {
byte[] buffer = new byte[] {
Integer.valueOf("01111111", 2).byteValue(),
Integer.valueOf("10100111", 2).byteValue(),
Integer.valueOf("11000001", 2).byteValue(),
Integer.valueOf("10000000", 2).byteValue()
};
Data data = new Data(buffer);
assertEquals(32, data.written());
assertEquals(32, data.readable());
assertEquals(4, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(32, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
BigInteger value = data.read(32, false);
assertEquals(32, data.written());
assertEquals(0, data.readable());
assertEquals(32, data.debug_GetRead());
assertEquals(32, data.debug_GetWrite());
assertEquals(
new BigInteger(
"01111111" +
"10100111" +
"11000001" +
"10000000", 2),
value);
} finally {
}
try {
byte[] buffer = new byte[] {
Integer.valueOf("11111111", 2).byteValue(),
Integer.valueOf("11010011", 2).byteValue(),
Integer.valueOf("01100000", 2).byteValue(),
Integer.valueOf("01000000", 2).byteValue()
};
Data data = new Data(buffer, 0, 31, true);
assertEquals(31, data.written());
assertEquals(31, data.readable());
assertEquals(4, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(31, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
BigInteger value = data.read(31, false);
assertEquals(31, data.written());
assertEquals(0, data.readable());
assertEquals(31, data.debug_GetRead());
assertEquals(31, data.debug_GetWrite());
assertEquals(
new BigInteger(
"01111111" +
"10100111" +
"11000001" +
"10000000", 2),
value);
} finally {
}
try {
byte[] buffer = new byte[] { 1 };
Data data = new Data(buffer);
assertEquals(0, data.read(0, true).intValue());
} finally {
}
}
@Test
public void fRead_int_boolean() throws Exception {
try {
Data data = new Data();
data.read(-1, true);
fail();
} catch (IllegalArgumentException ex) {
}
}
@Test
public void pWrite_BigInteger_int() throws Exception {
try {
BigInteger value = new BigInteger(
"01111111" +
"10100111" +
"11000001" +
"10000000", 2);
Data data = new Data(0);
assertEquals(0, data.written());
assertEquals(0, data.readable());
assertEquals(0, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(0, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
data.write(value, 32);
assertEquals(32, data.written());
assertEquals(32, data.readable());
assertEquals(128, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(32, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
assertEquals(Integer.valueOf("01111111", 2).byteValue(), data.debug_GetBuffer()[0]);
assertEquals(Integer.valueOf("10100111", 2).byteValue(), data.debug_GetBuffer()[1]);
assertEquals(Integer.valueOf("11000001", 2).byteValue(), data.debug_GetBuffer()[2]);
assertEquals(Integer.valueOf("10000000", 2).byteValue(), data.debug_GetBuffer()[3]);
} finally {
}
try {
BigInteger value = new BigInteger(
"01111111" +
"10100111" +
"11000001" +
"10000000", 2);
Data data = new Data(0);
assertEquals(0, data.written());
assertEquals(0, data.readable());
assertEquals(0, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(0, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
data.write(value, 31);
assertEquals(31, data.written());
assertEquals(31, data.readable());
assertEquals(128, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(31, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
assertEquals(Integer.valueOf("11111111", 2).byteValue(), data.debug_GetBuffer()[0]);
assertEquals(Integer.valueOf("11010011", 2).byteValue(), data.debug_GetBuffer()[1]);
assertEquals(Integer.valueOf("01100000", 2).byteValue(), data.debug_GetBuffer()[2]);
assertEquals(Integer.valueOf("01000000", 2).byteValue(), data.debug_GetBuffer()[3]);
} finally {
}
try {
Data data = new Data(0);
assertEquals(0, data.written());
assertEquals(0, data.readable());
assertEquals(0, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(0, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
data.write(BigInteger.ONE, 0);
assertEquals(0, data.written());
assertEquals(0, data.readable());
assertEquals(0, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(0, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
data.write(BigInteger.ONE, 1);
assertEquals(1, data.written());
assertEquals(1, data.readable());
assertEquals(128, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(1, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
} finally {
}
}
@Test
public void fWrite_BigInteger_int() throws Exception {
try {
Data data = new Data();
data.write(null, 0);
fail();
} catch (NullPointerException ex) {
}
try {
Data data = new Data();
data.write(BigInteger.ONE, -1);
fail();
} catch (IllegalArgumentException ex) {
}
}
@Test
public void pSkip_long() throws Exception {
try {
byte[] buffer = new byte[] {
Integer.valueOf("10000001", 2).byteValue(),
Integer.valueOf("00001000", 2).byteValue()
};
Data data = new Data(buffer);
assertEquals(0, data.skip(0));
assertEquals(true, data.read2());
assertEquals(6, data.skip(6));
assertEquals(true, data.read2());
assertEquals(3, data.skip(3));
assertEquals(true, data.read2());
assertEquals(4, data.skip(100));
assertEquals(0, data.skip(100));
} finally {
}
}
@Test
public void fSkip_long() throws Exception {
try {
Data data = new Data();
data.skip(-1);
fail();
} catch (IllegalArgumentException ex) {
}
}
@Test
public void pFill_int_long() throws Exception {
try {
Data data = new Data();
data.write(1);
data.fill(0, 4);
data.fill(1, 3);
data.fill(0, 0);
data.fill(0, 1);
data.write(0);
data.fill(1, 6);
assertEquals(16, data.written());
assertEquals(16, data.readable());
assertEquals(512, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(16, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
assertEquals(Integer.valueOf("11100001", 2).byteValue(), data.debug_GetBuffer()[0]);
assertEquals(Integer.valueOf("11111100", 2).byteValue(), data.debug_GetBuffer()[1]);
} finally {
}
}
@Test
public void fFill_int_long() throws Exception {
try {
Data data = new Data();
data.fill(1, -1);
fail();
} catch (IllegalArgumentException ex) {
}
}
@Test
public void pMark_void() throws Exception {
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer);
assertEquals(400, data.written());
assertEquals(400, data.readable());
assertEquals(50, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(400, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
data.skip(300);
data.mark();
assertEquals(100, data.readable());
assertEquals(300, data.debug_GetRead());
assertEquals(300, data.debug_GetMark());
data.skip(50);
assertEquals(50, data.readable());
assertEquals(350, data.debug_GetRead());
assertEquals(300, data.debug_GetMark());
assertEquals(true, data.reset());
assertEquals(100, data.readable());
assertEquals(300, data.debug_GetRead());
assertEquals(-1, data.debug_GetMark());
assertEquals(false, data.reset());
data.mark();
assertEquals(100, data.readable());
assertEquals(300, data.debug_GetRead());
assertEquals(300, data.debug_GetMark());
assertEquals(true, data.reset());
} finally {
}
}
@Test
public void fMark_void() throws Exception {
}
@Test
public void pReset_void() throws Exception {
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer);
assertEquals(400, data.written());
assertEquals(400, data.readable());
assertEquals(50, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(400, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
data.skip(300);
data.mark();
assertEquals(100, data.readable());
assertEquals(300, data.debug_GetRead());
assertEquals(300, data.debug_GetMark());
data.skip(50);
assertEquals(50, data.readable());
assertEquals(350, data.debug_GetRead());
assertEquals(300, data.debug_GetMark());
assertEquals(true, data.reset());
assertEquals(100, data.readable());
assertEquals(300, data.debug_GetRead());
assertEquals(-1, data.debug_GetMark());
assertEquals(false, data.reset());
data.mark();
assertEquals(100, data.readable());
assertEquals(300, data.debug_GetRead());
assertEquals(300, data.debug_GetMark());
assertEquals(true, data.reset());
} finally {
}
}
@Test
public void fReset_void() throws Exception {
}
@Test
public void pPull_void() throws Exception {
try {
byte[] buffer = new byte[50];
Data data = new Data(buffer);
assertEquals(400, data.written());
assertEquals(400, data.readable());
assertEquals(50, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(400, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
assertEquals(0, data.pull());
data.read();
assertEquals(7, data.pull());
assertEquals(0, data.pull());
} finally {
}
}
@Test
public void fPull_void() throws Exception {
}
@Test
public void pPush_void() throws Exception {
try {
Data data = new Data();
assertEquals(0, data.written());
assertEquals(0, data.readable());
assertEquals(512, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(0, data.debug_GetWrite());
assertEquals(RT.EOF, data.debug_GetMark());
assertEquals(0, data.push(0));
data.write(1);
assertEquals(7, data.push(0));
assertEquals(0, data.push(0));
} finally {
}
}
@Test
public void fPush_void() throws Exception {
}
@Test
public void pExport_longArray_boolean() throws Exception {
try {
byte[] buffer = new byte[] {
Integer.valueOf("01010101", 2).byteValue(),
Integer.valueOf("10101010", 2).byteValue()
};
Data data = new Data(buffer);
assertEquals(16, data.written());
assertEquals(16, data.readable());
assertEquals(2, data.debug_GetBuffer().length);
assertEquals(0, data.debug_GetRead());
assertEquals(16, data.debug_GetWrite());
data.skip(4);
long[] length = new long[1];
byte[] test = data.export(null, true);
assertEquals(Integer.valueOf("10100101", 2).byteValue(), test[0]);
assertEquals(Integer.valueOf("00001010", 2).byteValue(), test[1]);
length[0] = -1;
test = data.export(length, true);
assertEquals(12, length[0]);
assertEquals(Integer.valueOf("10100101", 2).byteValue(), test[0]);
assertEquals(Integer.valueOf("00001010", 2).byteValue(), test[1]);
length[0] = 4;
test = data.export(length, true);
assertEquals(4, length[0]);
assertEquals(Integer.valueOf("00000101", 2).byteValue(), test[0]);
length[0] = 10000;
test = data.export(length, true);
assertEquals(12, length[0]);
assertEquals(Integer.valueOf("10100101", 2).byteValue(), test[0]);
assertEquals(Integer.valueOf("00001010", 2).byteValue(), test[1]);
length[0] = 9;
test = data.export(length, true);
assertEquals(9, length[0]);
test = data.export(null, false);
assertEquals(Integer.valueOf("01010000", 2).byteValue(), test[0]);
assertEquals(Integer.valueOf("10101010", 2).byteValue(), test[1]);
length[0] = -1;
test = data.export(length, false);
assertEquals(16, length[0]);
assertEquals(Integer.valueOf("01010000", 2).byteValue(), test[0]);
assertEquals(Integer.valueOf("10101010", 2).byteValue(), test[1]);
length[0] = 4;
test = data.export(length, false);
assertEquals(8, length[0]);
assertEquals(Integer.valueOf("01010000", 2).byteValue(), test[0]);
length[0] = 10000;
test = data.export(length, false);
assertEquals(16, length[0]);
assertEquals(Integer.valueOf("01010000", 2).byteValue(), test[0]);
assertEquals(Integer.valueOf("10101010", 2).byteValue(), test[1]);
length[0] = 9;
test = data.export(length, false);
assertEquals(13, length[0]);
data.skip(5);
data.pull();
test = data.export(null, true);
assertEquals(0, test.length);
length[0] = 0;
test = data.export(length, true);
assertEquals(0, test.length);
length[0] = -1;
test = data.export(length, true);
assertEquals(0, test.length);
length[0] = 10000;
test = data.export(length, true);
assertEquals(0, test.length);
test = data.export(null, false);
assertEquals(0, test.length);
length[0] = 0;
test = data.export(length, false);
assertEquals(0, test.length);
length[0] = -1;
test = data.export(length, false);
assertEquals(0, test.length);
length[0] = 10000;
test = data.export(length, false);
assertEquals(0, test.length);
} finally {
}
}
@Test
public void fExport_longArray_boolean() throws Exception {
}
@Test
public void pIsPeek_void() throws Exception {
try {
Data data = new Data();
data.setPeek(true);
assertEquals(true, data.isPeek());
data.setPeek(false);
assertEquals(false, data.isPeek());
} finally {
}
}
@Test
public void fIsPeek_void() throws Exception {
}
@Test
public void pSetPeek_void() throws Exception {
try {
Data data = new Data(new byte[] {
Integer.valueOf("01010101", 2).byteValue()
});
assertEquals(0, data.debug_GetRead());
data.mark();
assertEquals(1, data.read());
assertEquals(1, data.debug_GetRead());
data.reset();
data.setPeek(true);
assertEquals(1, data.read());
assertEquals(0, data.debug_GetRead());
data.setPeek(false);
assertEquals(1, data.read());
assertEquals(1, data.debug_GetRead());
} finally {
}
}
@Test
public void fSetPeek_void() throws Exception {
}
}