package com.limegroup.gnutella.messages;
import java.io.ByteArrayOutputStream;
import java.util.Arrays;
import java.util.Set;
import java.util.List;
import java.util.LinkedList;
import com.limegroup.gnutella.util.NameValue;
import com.limegroup.gnutella.util.IOUtils;
import junit.framework.Test;
public class GGEPTest extends com.limegroup.gnutella.util.BaseTestCase {
public GGEPTest(String name) {
super(name);
}
public static Test suite() {
return buildTestSuite(GGEPTest.class);
}
public void testCOBS() throws Exception {
byte[] nulls = new byte[10];
for (int i = 0; i < nulls.length; i++)
nulls[i] = (byte)(i % 2);
String someNulls = "Hello" + new String(nulls);
try {
GGEP one = new GGEP(false);
one.put("Susheel", nulls);
one.put("Daswani", someNulls);
one.put("Number", 10);
ByteArrayOutputStream oStream = new ByteArrayOutputStream();
one.write(oStream);
GGEP two = new GGEP(oStream.toByteArray(), 0, null);
assertTrue(two.hasKey("Susheel"));
byte[] shouldBeNulls = two.getBytes("Susheel");
assertEquals(nulls, shouldBeNulls);
assertEquals(someNulls, two.getString("Daswani"));
assertEquals(10, two.getInt("Number"));
}
catch (IllegalArgumentException illegal) {
fail("The .put method failed!! ", illegal);
}
}
public void testPutAll() throws Exception {
List putm = new LinkedList();
putm.add(new NameValue("int", new Integer(1)));
putm.add(new NameValue("header"));
putm.add(new NameValue("long", new Long(2)));
putm.add(new NameValue("string", "value"));
putm.add(new NameValue("byte[]", new byte[] { 1, 2 } ));
GGEP temp = new GGEP(true);
temp.putAll(putm);
assertTrue(temp.hasKey("int"));
assertEquals(1, temp.getInt("int"));
assertTrue(temp.hasKey("header"));
assertTrue(temp.hasKey("long"));
assertEquals(2, temp.getLong("long"));
assertTrue(temp.hasKey("string"));
assertEquals("value", temp.getString("string"));
assertTrue(temp.hasKey("byte[]"));
assertEquals(new byte[] { 1, 2 }, temp.getBytes("byte[]"));
}
public void testStringKeys() throws Exception {
GGEP temp = new GGEP(true);
temp.put("A", "B");
temp.put("C", (String)null);
temp.put(GGEP.GGEP_HEADER_BROWSE_HOST, "");
assertTrue(temp.hasKey("A"));
assertEquals("B", temp.getString("A"));
assertTrue(temp.hasKey("C"));
assertTrue(temp.hasKey(GGEP.GGEP_HEADER_BROWSE_HOST));
assertEquals("", temp.getString(GGEP.GGEP_HEADER_BROWSE_HOST));
}
public void testByteKeys() throws Exception {
GGEP temp = new GGEP(true);
temp.put("A", new byte[] { (byte)3 });
assertTrue(temp.hasKey("A"));
assertEquals(temp.getBytes("A"), new byte[] { (byte)3 });
}
public void testIntKeys() throws Exception {
GGEP temp = new GGEP(true);
temp.put("A", 527);
assertTrue(temp.hasKey("A"));
assertEquals(527, temp.getInt("A"));
assertEquals(temp.getBytes("A"),
new byte[] { (byte)0x0F, (byte)0x02 });
}
public void testLongKeys() throws Exception {
GGEP temp = new GGEP(true);
temp.put("A", 0xABCDL);
assertTrue(temp.hasKey("A"));
assertEquals(0xABCDL, temp.getLong("A"));
assertEquals(temp.getBytes("A"), new byte[] {(byte)0xCD,(byte)0xAB} );
temp.put("A", 0x00ABCDEF12L);
assertTrue(temp.hasKey("A"));
assertEquals(0xABCDEF12L, temp.getLong("A"));
assertEquals(temp.getBytes("A"), new byte[] {
(byte)0x12, (byte)0xEF, (byte)0xCD, (byte)0xAB });
}
/** Tests that map constructor doesn't accept keys that are too long, should
* throw an exception */
public void testKeyTooBig() {
try {
GGEP temp = new GGEP(true);
temp.put("THIS KEY IS WAY TO LONG!", "");
fail("No IllegalArgumentException.");
} catch (IllegalArgumentException pass) {
}
}
/** Tests that map constructor doesn't accept data that is too long, should
* throw an exception. */
public void testValueTooBig() {
StringBuffer bigBoy = new StringBuffer(GGEP.MAX_VALUE_SIZE_IN_BYTES+10);
for (int i = 0; i < GGEP.MAX_VALUE_SIZE_IN_BYTES+10; i++)
bigBoy.append("1");
try {
GGEP temp = new GGEP(true);
temp.put("WHATEVER", bigBoy.toString());
fail("No IllegalArgumentException.");
} catch (IllegalArgumentException pass) { }
}
/** Test to see if the GGEP can handle datalens that are pretty big....
*/
public void testBigValue() throws Exception {
StringBuffer bigBoy = new StringBuffer(GGEP.MAX_VALUE_SIZE_IN_BYTES);
for (int i = 0; i < GGEP.MAX_VALUE_SIZE_IN_BYTES; i++)
bigBoy.append("1");
String[] keys = {"Susheel", "is", "an", "Idiot!!"};
GGEP temp = new GGEP(true);
for (int i = 0; i < keys.length; i++)
temp.put(keys[i], bigBoy.toString());
ByteArrayOutputStream baos = new ByteArrayOutputStream();
temp.write(baos);
byte[] ggepBytes = baos.toByteArray();
GGEP reconstruct = new GGEP(ggepBytes, 0, null);
for (int i = 0; i < keys.length; i++) {
String currValue = reconstruct.getString(keys[i]);
assertEquals(currValue, bigBoy.toString());
}
}
/** Null bytes allowed, e.g., in ping replies */
public void testValueContainsLegalNull() {
byte[] bytes = new byte[2];
bytes[0] = (byte)'S';
bytes[1] = (byte)0x0;
String hasANull = new String(bytes);
GGEP temp = new GGEP(true);
temp.put("WHATEVER", hasANull);
}
/** Null bytes are always allowed now.
*/
public void testValueContainsIllegalNull() {
byte[] bytes = new byte[2];
bytes[0] = (byte)'S';
bytes[1] = (byte)0x0;
String hasANull = new String(bytes);
GGEP temp = new GGEP(false);
temp.put("WHATEVER", hasANull);
}
public void testEquals() {
GGEP a1=new GGEP(true);
a1.put("K1", "V1");
GGEP a2=new GGEP(true);
a2.put("K1", "V1");
GGEP b1=new GGEP(true);
b1.put("K1");
GGEP b2=new GGEP(true);
b2.put("K1");
assertEquals(a1, a1);
assertEquals(a1, a2);
assertEquals(b1, b1);
assertEquals(b1, b2);
assertNotEquals(a1, b1);
assertNotEquals(b1, a1);
GGEP c1=new GGEP(true);
c1.put("K1", "V1");
c1.put("K2", "V2");
GGEP c2=new GGEP(true);
c2.put("K1", "V1");
c2.put("K2", "V2");
assertEquals(c1, c1);
assertEquals(c1, c2);
assertNotEquals(a1, c1);
assertNotEquals(b1, c1);
}
public void testPutCompressed() throws Exception {
byte[] middleValue = "middle".getBytes();
GGEP g = new GGEP();
g.put("1", "begin");
g.putCompressed("2", middleValue);
g.put("3", "end");
ByteArrayOutputStream out = new ByteArrayOutputStream();
g.write(out);
byte[] bytes = out.toByteArray();
int i = 0;
assertEquals(GGEP.GGEP_PREFIX_MAGIC_NUMBER, bytes[i++]);
assertEquals( (byte)0x01, bytes[i++] );
assertEquals( (byte)'1', bytes[i++] );
assertEquals( (byte)0x45, bytes[i++] );
assertEquals( (byte)'b', bytes[i++] );
assertEquals( (byte)'e', bytes[i++] );
assertEquals( (byte)'g', bytes[i++] );
assertEquals( (byte)'i', bytes[i++] );
assertEquals( (byte)'n', bytes[i++] );
assertEquals( (byte)0x21, bytes[i++] );
assertEquals( (byte)'2', bytes[i++] );
// now, we have to figure out how many bytes are used up in the
// compressed version of 'middle'.
byte[] compressed = IOUtils.deflate(middleValue);
assertNotEquals(middleValue, compressed);
int length = compressed.length;
if((length & 0x3F000) != 0)
assertEquals( (byte)0x80 | ((length & 0x3F000) >> 12), bytes[i++]);
if((length & 0xFC0) != 0)
assertEquals( (byte)0x80 | ((length & 0xFC0) >> 6), bytes[i++]);
assertEquals((byte)0x40 | (length & 0x3F), bytes[i++]);
for(int j = 0; j < compressed.length; j++)
assertEquals(compressed[j], bytes[i++]);
// end of checking for the compressed data.
assertEquals( (byte)0x81, bytes[i++] );
assertEquals( (byte)'3', bytes[i++] );
assertEquals( (byte)0x43, bytes[i++] );
assertEquals( (byte)'e', bytes[i++] );
assertEquals( (byte)'n', bytes[i++] );
assertEquals( (byte)'d', bytes[i++] );
}
public void testReadCompressedAndWritesCompressed() throws Exception {
ByteArrayOutputStream out = new ByteArrayOutputStream();
out.write(GGEP.GGEP_PREFIX_MAGIC_NUMBER);
out.write(0x01);
out.write('1');
out.write(0x45);
out.write('b');
out.write('e');
out.write('g');
out.write('i');
out.write('n');
out.write(0x21);
out.write('2');
byte[] middleValue = "the middle value, compressed.".getBytes();
byte[] compressed = IOUtils.deflate(middleValue);
assertNotEquals(middleValue, compressed);
int length = compressed.length;
if((length & 0x3F000) != 0)
out.write( (byte)0x80 | ((length & 0x3F000) >> 12));
if((length & 0xFC0) != 0)
out.write( (byte)0x80 | ((length & 0xFC0) >> 6));
out.write((byte)0x40 | (length & 0x3F));
out.write(compressed);
out.write(0x81);
out.write('3');
out.write(0x43);
out.write('e');
out.write('n');
out.write('d');
int offsets[] = new int[1];
byte[] bytes = out.toByteArray();
GGEP ggep = new GGEP(bytes, 0, offsets);
assertEquals(bytes.length, offsets[0]);
assertEquals(3, ggep.getHeaders().size());
assertEquals("begin", ggep.getString("1"));
assertEquals(new String(middleValue), ggep.getString("2"));
assertEquals("end", ggep.getString("3"));
// Make sure that also write the data as compressed, if it was read that way.
ByteArrayOutputStream toWrite = new ByteArrayOutputStream();
ggep.write(toWrite);
assertEquals(bytes, toWrite.toByteArray());
}
public void testBasicConstruction() throws Exception {
byte[] bytes = new byte[24];
bytes[0] = GGEP.GGEP_PREFIX_MAGIC_NUMBER;
bytes[1] = (byte)0x05;
bytes[2] = (byte)'B';
bytes[3] = (byte)'H';
bytes[4] = (byte)'O';
bytes[5] = (byte)'S';
bytes[6] = (byte)'T';
bytes[7] = (byte)0x40;
bytes[8] = (byte)0x87;
bytes[9] = (byte)'S';
bytes[10] = (byte)'U';
bytes[11] = (byte)'S';
bytes[12] = (byte)'H';
bytes[13] = (byte)'E';
bytes[14] = (byte)'E';
bytes[15] = (byte)'L';
bytes[16] = (byte)0x47;
bytes[17] = (byte)'D';
bytes[18] = (byte)'A';
bytes[19] = (byte)'S';
bytes[20] = (byte)'W';
bytes[21] = (byte)'A';
bytes[22] = (byte)'N';
bytes[23] = (byte)'I';
GGEP ggep = new GGEP(bytes, 0);
bytes = new byte[32];
bytes[0] = GGEP.GGEP_PREFIX_MAGIC_NUMBER;
bytes[1] = (byte)0x85;
bytes[2] = (byte)'B';
bytes[3] = (byte)'H';
bytes[4] = (byte)'O';
bytes[5] = (byte)'S';
bytes[6] = (byte)'T';
bytes[7] = (byte)0x40;
bytes[8] = GGEP.GGEP_PREFIX_MAGIC_NUMBER;
bytes[9] = (byte)0x05;
bytes[10] = (byte)'B';
bytes[11] = (byte)'H';
bytes[12] = (byte)'O';
bytes[13] = (byte)'S';
bytes[14] = (byte)'T';
bytes[15] = (byte)0x40;
bytes[16] = (byte)0x87;
bytes[17] = (byte)'S';
bytes[18] = (byte)'U';
bytes[19] = (byte)'S';
bytes[20] = (byte)'H';
bytes[21] = (byte)'E';
bytes[22] = (byte)'E';
bytes[23] = (byte)'L';
bytes[24] = (byte)0x47;
bytes[25] = (byte)'D';
bytes[26] = (byte)'A';
bytes[27] = (byte)'S';
bytes[28] = (byte)'W';
bytes[29] = (byte)'A';
bytes[30] = (byte)'N';
bytes[31] = (byte)'I';
ggep = new GGEP(bytes, 0);
assertEquals(1, ggep.getHeaders().size());
assertTrue(ggep.hasKey("BHOST"));
ggep = new GGEP(bytes, 8);
assertEquals(2, ggep.getHeaders().size());
assertTrue(ggep.hasKey("BHOST"));
assertTrue(ggep.hasKey("SUSHEEL"));
assertEquals("DASWANI", ggep.getString("SUSHEEL"));
bytes = new byte[24];
bytes[0] = (byte)GGEP.GGEP_PREFIX_MAGIC_NUMBER;
bytes[1] = (byte)0x15;
bytes[2] = (byte)'B';
bytes[3] = (byte)'H';
bytes[4] = (byte)'O';
bytes[5] = (byte)'S';
bytes[6] = (byte)'T';
bytes[7] = (byte)0x40;
bytes[8] = (byte)0x87;
bytes[9] = (byte)'S';
bytes[10] = (byte)'U';
bytes[11] = (byte)'S';
bytes[12] = (byte)'H';
bytes[13] = (byte)'E';
bytes[14] = (byte)'E';
bytes[15] = (byte)'L';
bytes[16] = (byte)0x47;
bytes[17] = (byte)'D';
bytes[18] = (byte)'A';
bytes[19] = (byte)'S';
bytes[20] = (byte)'W';
bytes[21] = (byte)'A';
bytes[22] = (byte)'N';
bytes[23] = (byte)'I';
try {
ggep = new GGEP(bytes, 0);
fail("should have constructed");
} catch (BadGGEPBlockException expected) {}
}
// tests normal behavior of the byte[] constructor
public void testByteArrayConstructor1() throws Exception {
int[] endOffset = new int[1];
byte[] bytes = new byte[24];
bytes[0] = GGEP.GGEP_PREFIX_MAGIC_NUMBER;
bytes[1] = (byte)0x05;
bytes[2] = (byte)'B';
bytes[3] = (byte)'H';
bytes[4] = (byte)'O';
bytes[5] = (byte)'S';
bytes[6] = (byte)'T';
bytes[7] = (byte)0x40;
bytes[8] = (byte)0x87;
bytes[9] = (byte)'S';
bytes[10] = (byte)'U';
bytes[11] = (byte)'S';
bytes[12] = (byte)'H';
bytes[13] = (byte)'E';
bytes[14] = (byte)'E';
bytes[15] = (byte)'L';
bytes[16] = (byte)0x47;
bytes[17] = (byte)'D';
bytes[18] = (byte)'A';
bytes[19] = (byte)'S';
bytes[20] = (byte)'W';
bytes[21] = (byte)'A';
bytes[22] = (byte)'N';
bytes[23] = (byte)'I';
GGEP temp = new GGEP(bytes,0, endOffset);
Set headers = temp.getHeaders();
assertTrue("Test 5 - NO BHOST!", headers.contains("BHOST"));
try {
temp.getString("BHOST");
fail("No BadGGEPPropertyException.");
} catch (BadGGEPPropertyException e) {
}
assertTrue("Test 5 - NO SUSH!", headers.contains("SUSHEEL"));
Object shouldNotBeNull = temp.getString("SUSHEEL");
assertNotNull(shouldNotBeNull);
assertEquals(24, endOffset[0]);
}
// tests abnormal behavior of the byte[] constructor - tries to give
// compressed data, a 0 header length, and a data length
// which is stored in more than 3 bytes...
public void testByteArrayConstructor2() throws Exception {
byte[] bytes = new byte[24];
bytes[0] = GGEP.GGEP_PREFIX_MAGIC_NUMBER;
bytes[1] = (byte)0x05;
bytes[2] = (byte)'B';
bytes[3] = (byte)'H';
bytes[4] = (byte)'O';
bytes[5] = (byte)'S';
bytes[6] = (byte)'T';
bytes[7] = (byte)0x40;
bytes[8] = (byte)0x87;
bytes[9] = (byte)'S';
bytes[10] = (byte)'U';
bytes[11] = (byte)'S';
bytes[12] = (byte)'H';
bytes[13] = (byte)'E';
bytes[14] = (byte)'E';
bytes[15] = (byte)'L';
bytes[16] = (byte)0x47;
bytes[17] = (byte)'D';
bytes[18] = (byte)'A';
bytes[19] = (byte)'S';
bytes[20] = (byte)'W';
bytes[21] = (byte)'A';
bytes[22] = (byte)'N';
bytes[23] = (byte)'I';
bytes[8] = (byte)0xA5; // compressed, without valid data.
GGEP temp;
try {
temp = new GGEP(bytes,0,null);
fail("shoulda failed");
} catch(BadGGEPBlockException bgbe) {}
bytes[8] = (byte)0x80; // 0 len header
try {
temp = new GGEP(bytes,0,null);
assertTrue("Test 6 - 0 LEN HEADER!", false);
}
catch (BadGGEPBlockException hopefullySo) {
}
bytes[8] = (byte)0x87;
bytes[16] = (byte)0xBF;
bytes[17] = (byte)0xBF;
bytes[18] = (byte)0xBF;
bytes[19] = (byte)0xBF;
try {
temp = new GGEP(bytes,0,null);
assertTrue("Test 6 - >3 DATA LEN!", false);
}
catch (BadGGEPBlockException hopefullySo) {
}
}
public void testWriteMethod() throws Exception {
GGEP one = null, two = null;
byte[] bytes = new byte[24];
bytes[0] = GGEP.GGEP_PREFIX_MAGIC_NUMBER;
bytes[1] = (byte)0x05;
bytes[2] = (byte)'B';
bytes[3] = (byte)'H';
bytes[4] = (byte)'O';
bytes[5] = (byte)'S';
bytes[6] = (byte)'T';
bytes[7] = (byte)0x40;
bytes[8] = (byte)0x87;
bytes[9] = (byte)'S';
bytes[10] = (byte)'U';
bytes[11] = (byte)'S';
bytes[12] = (byte)'H';
bytes[13] = (byte)'E';
bytes[14] = (byte)'E';
bytes[15] = (byte)'L';
bytes[16] = (byte)0x47;
bytes[17] = (byte)'D';
bytes[18] = (byte)'A';
bytes[19] = (byte)'S';
bytes[20] = (byte)'W';
bytes[21] = (byte)'A';
bytes[22] = (byte)'N';
bytes[23] = (byte)'I';
one = new GGEP(bytes,0,null);
ByteArrayOutputStream oStream = new ByteArrayOutputStream();
one.write(oStream);
two = new GGEP(oStream.toByteArray(), 0, null);
assertEquals(one.getHeaders(), two.getHeaders());
assertEquals(one, two);
}
public void testMalformedGGEP() throws Exception {
GGEP one = null;
byte[] bytes = new byte[24];
bytes[0] = GGEP.GGEP_PREFIX_MAGIC_NUMBER;
bytes[1] = (byte)0x05;
bytes[2] = (byte)'B';
bytes[3] = (byte)'H';
bytes[4] = (byte)'O';
bytes[5] = (byte)'S';
bytes[6] = (byte)'T';
bytes[7] = (byte)0x40;
bytes[8] = (byte)0x87;
bytes[9] = (byte)'S';
bytes[10] = (byte)'U';
bytes[11] = (byte)'S';
bytes[12] = (byte)'H';
bytes[13] = (byte)'E';
bytes[14] = (byte)'E';
bytes[15] = (byte)'L';
bytes[16] = (byte)0x47;
bytes[17] = (byte)'D';
bytes[18] = (byte)'A';
bytes[19] = (byte)'S';
bytes[20] = (byte)'W';
bytes[21] = (byte)'A';
bytes[22] = (byte)'N';
bytes[23] = (byte)'I';
// test first case where no magic number....
bytes[0] = (byte) 'I';
try {
one = new GGEP(bytes,0,null);
fail("need to fail.");
}
catch (BadGGEPBlockException hopefullySo) {
}
// now test a ID Len that is lying!
bytes = new byte[6];
bytes[0] = GGEP.GGEP_PREFIX_MAGIC_NUMBER;
bytes[1] = (byte)0x05;
bytes[2] = (byte)'B';
bytes[3] = (byte)'H';
bytes[4] = (byte)'O';
bytes[5] = (byte)'S';
try {
one = new GGEP(bytes,0,null);
fail("need to fail.");
}
catch (BadGGEPBlockException hopefullySo) {
}
// too many data length fields...
bytes = new byte[24];
bytes[0] = GGEP.GGEP_PREFIX_MAGIC_NUMBER;
bytes[1] = (byte)0x05;
bytes[2] = (byte)'B';
bytes[3] = (byte)'H';
bytes[4] = (byte)'O';
bytes[5] = (byte)'S';
bytes[6] = (byte)'T';
bytes[7] = (byte)0xbf;
bytes[8] = (byte)0xbf;
bytes[9] = (byte)0xbf;
bytes[10] = (byte)'U';
bytes[11] = (byte)'S';
bytes[12] = (byte)'H';
bytes[13] = (byte)'E';
bytes[14] = (byte)'E';
bytes[15] = (byte)'L';
bytes[16] = (byte)0x47;
bytes[17] = (byte)'D';
bytes[18] = (byte)'A';
bytes[19] = (byte)'S';
bytes[20] = (byte)'W';
bytes[21] = (byte)'A';
bytes[22] = (byte)'N';
bytes[23] = (byte)'I';
try {
one = new GGEP(bytes,0,null);
fail("need to fail");
}
catch (BadGGEPBlockException hopefullySo) {
}
// not enough data length fields...
bytes = new byte[9];
bytes[0] = GGEP.GGEP_PREFIX_MAGIC_NUMBER;
bytes[1] = (byte)0x05;
bytes[2] = (byte)'B';
bytes[3] = (byte)'H';
bytes[4] = (byte)'O';
bytes[5] = (byte)'S';
bytes[6] = (byte)'T';
bytes[7] = (byte)0xbf;
bytes[8] = (byte)0xbf;
try {
one = new GGEP(bytes,0,null);
fail("need to fail");
}
catch (BadGGEPBlockException hopefullySo) {
}
// not enough bytes!
bytes = new byte[0];
try {
one = new GGEP(bytes,0,null);
fail("need to fail");
}
catch (BadGGEPBlockException hopefullySo) {
}
// not enough data fields...
bytes = new byte[22];
bytes[0] = GGEP.GGEP_PREFIX_MAGIC_NUMBER;
bytes[1] = (byte)0x05;
bytes[2] = (byte)'B';
bytes[3] = (byte)'H';
bytes[4] = (byte)'O';
bytes[5] = (byte)'S';
bytes[6] = (byte)'T';
bytes[7] = (byte)0x40;
bytes[8] = (byte)0x87;
bytes[9] = (byte)'S';
bytes[10] = (byte)'U';
bytes[11] = (byte)'S';
bytes[12] = (byte)'H';
bytes[13] = (byte)'E';
bytes[14] = (byte)'E';
bytes[15] = (byte)'L';
bytes[16] = (byte)0x47;
bytes[17] = (byte)'D';
bytes[18] = (byte)'A';
bytes[19] = (byte)'S';
bytes[20] = (byte)'W';
bytes[21] = (byte)'A';
try {
one = new GGEP(bytes,0,null);
fail("need to fail");
}
catch (BadGGEPBlockException hopefullySo) {
}
// just a messed up GGEP block...
bytes = new byte[22];
bytes[0] = GGEP.GGEP_PREFIX_MAGIC_NUMBER;
bytes[1] = (byte)0x05;
bytes[2] = (byte)'B';
bytes[3] = (byte)'H';
bytes[4] = (byte)'O';
bytes[5] = (byte)'S';
bytes[6] = (byte)'T';
bytes[7] = (byte)0x40;
bytes[8] = (byte)'S';
bytes[9] = (byte)'S';
bytes[10] = (byte)'U';
bytes[11] = (byte)'S';
bytes[12] = (byte)'H';
bytes[13] = (byte)'E';
bytes[14] = (byte)'E';
bytes[15] = (byte)'L';
bytes[16] = (byte)0x47;
bytes[17] = (byte)'D';
bytes[18] = (byte)'A';
bytes[19] = (byte)'S';
bytes[20] = (byte)'W';
bytes[21] = (byte)'A';
bytes[21] = (byte)'N';
bytes[21] = (byte)'I';
try {
one = new GGEP(bytes,0,null);
fail("need to fail");
}
catch (BadGGEPBlockException hopefullySo) {
}
}
public void testMissingMiddleValueSize() throws Exception {
int length = 0x0003f03f; // in the size 258111, the 6 bytes in the middle are missing 00000000 00000011 11110000 00111111
GGEP ggep = new GGEP(true); // don't do COBS encoding
byte[] value = new byte[length];
ggep.put("TEST", value);
// serialize it to data
ByteArrayOutputStream out = new ByteArrayOutputStream();
ggep.write(out);
byte[] serialized = out.toByteArray();
// turn that back into a new GGEP block and make sure it's the same
GGEP ggep2 = new GGEP(serialized, 0);
byte[] value2 = ggep2.getBytes("TEST");
assertEquals(value.length, value2.length);
}
public static void main(String argv[]) {
junit.textui.TestRunner.run(suite());
}
}