public void testBytes_to_double()
{
try {
PickleUtils.bytes_to_double(new byte[] {}, 0);
Assert.Fail("expected PickleException");
} catch (PickleException) {}
try {
PickleUtils.bytes_to_double(new byte[] { 0 }, 0);
Assert.Fail("expected PickleException");
} catch (PickleException) {}
Assert.AreEqual(0.0d, PickleUtils.bytes_to_double(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, 0));
Assert.AreEqual(1.0d, PickleUtils.bytes_to_double(new byte[] { 0x3f, 0xf0, 0, 0, 0, 0, 0, 0 }, 0));
Assert.AreEqual(1.1d, PickleUtils.bytes_to_double(new byte[] { 0x3f, 0xf1, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a }, 0));
Assert.AreEqual(1234.5678d, PickleUtils.bytes_to_double(new byte[] { 0x40, 0x93, 0x4a, 0x45, 0x6d, 0x5c, 0xfa, 0xad }, 0));
Assert.AreEqual(2.17e123d, PickleUtils.bytes_to_double(new byte[] { 0x59, 0x8a, 0x42, 0xd1, 0xce, 0xf5, 0x3f, 0x46 }, 0));
Assert.AreEqual(1.23456789e300d, PickleUtils.bytes_to_double(new byte[] { 0x7e, 0x3d, 0x7e, 0xe8, 0xbc, 0xaf, 0x28, 0x3a }, 0));
Assert.AreEqual(double.PositiveInfinity, PickleUtils.bytes_to_double(new byte[] { 0x7f, 0xf0, 0, 0, 0, 0, 0, 0 }, 0));
Assert.AreEqual(double.NegativeInfinity, PickleUtils.bytes_to_double(new byte[] { 0xff, 0xf0, 0, 0, 0, 0, 0, 0 }, 0));
try
{
PickleUtils.bytes_to_double(new byte[] { 200, 50, 25, 100 }, 0);
Assert.Fail("expected PickleException");
} catch (PickleException) {}
// test offset
Assert.AreEqual(1.23456789e300d, PickleUtils.bytes_to_double(new byte[] { 0, 0, 0, 0x7e, 0x3d, 0x7e, 0xe8, 0xbc, 0xaf, 0x28, 0x3a }, 3));
Assert.AreEqual(1.23456789e300d, PickleUtils.bytes_to_double(new byte[] { 0x7e, 0x3d, 0x7e, 0xe8, 0xbc, 0xaf, 0x28, 0x3a, 0, 0, 0 }, 0));
}
protected long[] constructLongArrayFromInt64(int machinecode, byte[] data)
{
long[] result = new long[data.Length / 8];
byte[] bigendian = new byte[8];
for (int i = 0; i < data.Length / 8; i++)
{
if (machinecode == 12)
{
// little endian can go
result[i] = PickleUtils.bytes_to_long(data, i * 8);
}
else
{
// 13=big endian, swap
bigendian[0] = data[7 + i * 8];
bigendian[1] = data[6 + i * 8];
bigendian[2] = data[5 + i * 8];
bigendian[3] = data[4 + i * 8];
bigendian[4] = data[3 + i * 8];
bigendian[5] = data[2 + i * 8];
bigendian[6] = data[1 + i * 8];
bigendian[7] = data[0 + i * 8];
result[i] = PickleUtils.bytes_to_long(bigendian, 0);
}
}
return(result);
}
public void testBytes_to_integer()
{
try {
PickleUtils.bytes_to_integer(new byte[] {});
Assert.Fail("expected PickleException");
} catch (PickleException) {}
try {
PickleUtils.bytes_to_integer(new byte[] { 0 });
Assert.Fail("expected PickleException");
} catch (PickleException) {}
Assert.AreEqual(0x00000000, PickleUtils.bytes_to_integer(new byte[] { 0x00, 0x00 }));
Assert.AreEqual(0x00003412, PickleUtils.bytes_to_integer(new byte[] { 0x12, 0x34 }));
Assert.AreEqual(0x0000ffff, PickleUtils.bytes_to_integer(new byte[] { 0xff, 0xff }));
Assert.AreEqual(0x00000000, PickleUtils.bytes_to_integer(new byte[] { 0, 0, 0, 0 }));
Assert.AreEqual(0x12345678, PickleUtils.bytes_to_integer(new byte[] { 0x78, 0x56, 0x34, 0x12 }));
Assert.AreEqual(-8380352, PickleUtils.bytes_to_integer(new byte[] { 0x40, 0x20, 0x80, 0xff }));
Assert.AreEqual(0x01cc02ee, PickleUtils.bytes_to_integer(new byte[] { 0xee, 0x02, 0xcc, 0x01 }));
Assert.AreEqual(-872288766, PickleUtils.bytes_to_integer(new byte[] { 0x02, 0xee, 0x01, 0xcc }));
Assert.AreEqual(-285212674, PickleUtils.bytes_to_integer(new byte[] { 0xfe, 0xff, 0xff, 0xee }));
try
{
PickleUtils.bytes_to_integer(new byte[] { 200, 50, 25, 100, 1, 2, 3, 4 });
Assert.Fail("expected PickleException");
} catch (PickleException) {}
}
protected double[] constructDoubleArray(int machinecode, byte[] data)
{
double[] result = new double[data.Length / 8];
byte[] bigendian = new byte[8];
for (int i = 0; i < data.Length / 8; ++i)
{
if (machinecode == 16)
{
result[i] = PickleUtils.bytes_to_double(data, i * 8);
}
else
{
// 17=big endian, flip the bytes
bigendian[0] = data[7 + i * 8];
bigendian[1] = data[6 + i * 8];
bigendian[2] = data[5 + i * 8];
bigendian[3] = data[4 + i * 8];
bigendian[4] = data[3 + i * 8];
bigendian[5] = data[2 + i * 8];
bigendian[6] = data[1 + i * 8];
bigendian[7] = data[0 + i * 8];
result[i] = PickleUtils.bytes_to_double(bigendian, 0);
}
}
return(result);
}
protected char[] constructCharArrayUTF32(int machinecode, byte[] data)
{
char[] result = new char[data.Length / 4];
byte[] bigendian = new byte[4];
for (int index = 0; index < data.Length / 4; ++index)
{
if (machinecode == 20)
{
int codepoint = PickleUtils.bytes_to_integer(data, index * 4, 4);
string cc = char.ConvertFromUtf32(codepoint);
if (cc.Length > 1)
{
throw new PickleException("cannot process UTF-32 character codepoint " + codepoint);
}
result[index] = cc[0];
}
else
{
// big endian, swap
bigendian[0] = data[3 + index * 4];
bigendian[1] = data[2 + index * 4];
bigendian[2] = data[1 + index * 4];
bigendian[3] = data[index * 4];
int codepoint = PickleUtils.bytes_to_integer(bigendian);
string cc = char.ConvertFromUtf32(codepoint);
if (cc.Length > 1)
{
throw new PickleException("cannot process UTF-32 character codepoint " + codepoint);
}
result[index] = cc[0];
}
}
return(result);
}
protected float[] constructFloatArray(int machinecode, byte[] data)
{
var result = new float[data.Length / 4];
if (machinecode == 15)
{
for (int i = 0; i < result.Length; i++)
{
result[i] = PickleUtils.bytes_bigendian_to_float(data, i * 4);
}
}
else
{
var bigendian = new byte[4];
for (int i = 0; i < result.Length; i++)
{
// 14=little endian, flip the bytes
bigendian[0] = data[3 + i * 4];
bigendian[1] = data[2 + i * 4];
bigendian[2] = data[1 + i * 4];
bigendian[3] = data[0 + i * 4];
result[i] = PickleUtils.bytes_bigendian_to_float(bigendian, 0);
}
}
return(result);
}
protected double[] constructDoubleArray(int machinecode, byte[] data)
{
var result = new double[data.Length / 8];
if (machinecode == 17)
{
for (int i = 0; i < result.Length; i++)
{
result[i] = PickleUtils.bytes_bigendian_to_double(data, i * 8);
}
}
else
{
var bigendian = new byte[8];
for (int i = 0; i < result.Length; i++)
{
// 16=little endian, flip the bytes
bigendian[0] = data[7 + i * 8];
bigendian[1] = data[6 + i * 8];
bigendian[2] = data[5 + i * 8];
bigendian[3] = data[4 + i * 8];
bigendian[4] = data[3 + i * 8];
bigendian[5] = data[2 + i * 8];
bigendian[6] = data[1 + i * 8];
bigendian[7] = data[0 + i * 8];
result[i] = PickleUtils.bytes_bigendian_to_double(bigendian, 0);
}
}
return(result);
}
protected uint[] constructUIntArrayFromUInt32(int machinecode, byte[] data)
{
var result = new uint[data.Length / 4];
if (machinecode == 6)
{
for (int i = 0; i < result.Length; i++)
{
result[i] = PickleUtils.bytes_to_uint(data, i * 4);
}
}
else
{
var bigendian = new byte[4];
for (int i = 0; i < result.Length; i++)
{
// big endian, swap
bigendian[0] = data[3 + i * 4];
bigendian[1] = data[2 + i * 4];
bigendian[2] = data[1 + i * 4];
bigendian[3] = data[0 + i * 4];
result[i] = PickleUtils.bytes_to_uint(bigendian, 0);
}
}
return(result);
}
public void TestBinint2WithObject()
{
Unpickler u = new Unpickler();
var data = PickleUtils.str2bytes("\u0080\u0002cIgnore.Ignore\nIgnore\n)\u0081M\u0082#.");
int result = (int)u.loads(data);
Assert.Equal(9090, result);
}
public void TestBYTEARRAY8()
{
// BYTEARRAY8 = 0x96 (pickle protocol 5)
Unpickler u = new Unpickler();
byte[] data = PickleUtils.str2bytes("\u0080\u0005\u0095\u000e\u0000\u0000\u0000\u0000\u0000\u0000\u0090\u0096\u0003\u0000\u0000\u0000\u0000\u0000\u0000\u0000abc\u0094.");
byte[] result = (byte[])u.loads(data);
Assert.Equal(new byte[] { 97, 98, 99 }, result);
}
public void TestDecode_unicode_escaped()
{
Assert.Equal("abc", PickleUtils.decode_unicode_escaped("abc"));
Assert.Equal("a\\c", PickleUtils.decode_unicode_escaped("a\\\\c"));
Assert.Equal("a\u0042c", PickleUtils.decode_unicode_escaped("a\\u0042c"));
Assert.Equal("a\nc", PickleUtils.decode_unicode_escaped("a\\nc"));
Assert.Equal("a\tc", PickleUtils.decode_unicode_escaped("a\\tc"));
Assert.Equal("a\rc", PickleUtils.decode_unicode_escaped("a\\rc"));
}
public void testDecode_escaped()
{
Assert.AreEqual("abc", PickleUtils.decode_escaped("abc"));
Assert.AreEqual("a\\c", PickleUtils.decode_escaped("a\\\\c"));
Assert.AreEqual("a\u0042c", PickleUtils.decode_escaped("a\\x42c"));
Assert.AreEqual("a\nc", PickleUtils.decode_escaped("a\\nc"));
Assert.AreEqual("a\tc", PickleUtils.decode_escaped("a\\tc"));
Assert.AreEqual("a\rc", PickleUtils.decode_escaped("a\\rc"));
Assert.AreEqual("a'c", PickleUtils.decode_escaped("a\\'c"));
}
public void testBinint2WithObject()
{
Unpickler u = new Unpickler();
Unpickler.registerConstructor("Pyro4.core", "URI", new StringConstructor());
byte[] data = PickleUtils.str2bytes("\u0080\u0002cPyro4.core\nURI\n)\u0081M\u0082#.");
int result = (int)u.loads(data);
Assert.AreEqual(9090, result);
}
public void TestInteger_to_bytes()
{
Assert.Equal(new byte[] { 0, 0, 0, 0 }, PickleUtils.integer_to_bytes(0));
Assert.Equal(new byte[] { 0x78, 0x56, 0x34, 0x12 }, PickleUtils.integer_to_bytes(0x12345678));
Assert.Equal(new byte[] { 0x40, 0x20, 0x80, 0xff }, PickleUtils.integer_to_bytes(-8380352));
Assert.Equal(new byte[] { 0xfe, 0xff, 0xff, 0xee }, PickleUtils.integer_to_bytes(-285212674));
Assert.Equal(new byte[] { 0xff, 0xff, 0xff, 0xff }, PickleUtils.integer_to_bytes(-1));
Assert.Equal(new byte[] { 0xee, 0x02, 0xcc, 0x01 }, PickleUtils.integer_to_bytes(0x01cc02ee));
Assert.Equal(new byte[] { 0x02, 0xee, 0x01, 0xcc }, PickleUtils.integer_to_bytes(-872288766));
}
public void TestReadbytes_into()
{
Stream bis = new MemoryStream(_filedata);
byte[] bytes = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
PickleUtils.readbytes_into(bis, bytes, 1, 4);
Assert.Equal(new byte[] { 0, 115, 116, 114, 49, 0, 0, 0, 0, 0 }, bytes);
PickleUtils.readbytes_into(bis, bytes, 8, 1);
Assert.Equal(new byte[] { 0, 115, 116, 114, 49, 0, 0, 0, 10, 0 }, bytes);
}
public void TestBINPERSID()
{
//BINPERSID = b'Q' # push persistent object; id is taken from stack
var pickle = PickleUtils.str2bytes("\u0080\u0004\u0095\u000f\u0000\u0000\u0000\u0000\u0000\u0000\u0000]\u0094(K*\u008c\u00049999\u0094Qe.");
Unpickler unpickler = new PersistentIdUnpickler();
IList result = (IList)unpickler.loads(pickle);
Assert.Equal(2, result.Count);
Assert.Equal(42, result[0]);
Assert.Equal("PersistentObject", result[1]);
}
public void TestPERSID()
{
//PERSID = b'P' # push persistent object; id is taken from string arg
var pickle = PickleUtils.str2bytes("(lp0\nI42\naP9999\na.");
Unpickler unpickler = new PersistentIdUnpickler();
IList result = (IList)unpickler.loads(pickle);
Assert.Equal(2, result.Count);
Assert.Equal(42, result[0]);
Assert.Equal("PersistentObject", result[1]);
}
public void testReadbytes_into()
{
Stream bis = new MemoryStream(filedata);
PickleUtils p = new PickleUtils(bis);
byte[] bytes = new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
p.readbytes_into(bytes, 1, 4);
Assert.AreEqual(new byte[] { 0, 115, 116, 114, 49, 0, 0, 0, 0, 0 }, bytes);
p.readbytes_into(bytes, 8, 1);
Assert.AreEqual(new byte[] { 0, 115, 116, 114, 49, 0, 0, 0, 10, 0 }, bytes);
}
public void TestProtocol5bytearray()
{
// ["string", bytearray(b'irmen')] -> produces a protocol 5 pickle with opcode BYTEARRAY8
Unpickler u = new Unpickler();
byte[] data = PickleUtils.str2bytes("\u0080\u0005\u0095\u001d\u0000\u0000\u0000\u0000\u0000\u0000\u0000]\u0094(\u008c\u0006string\u0094\u0096\u0005\u0000\u0000\u0000\u0000\u0000\u0000\u0000irmen\u0094e.");
ArrayList result = (ArrayList)u.loads(data);
Assert.Equal(2, result.Count);
Assert.Equal("string", result[0]);
Assert.Equal(new byte[] { 105, 114, 109, 101, 110 }, result[1]);
}
public void TestDouble_to_bytes()
{
Assert.Equal(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, PickleUtils.double_to_bytes_bigendian(0.0d));
Assert.Equal(new byte[] { 0x3f, 0xf0, 0, 0, 0, 0, 0, 0 }, PickleUtils.double_to_bytes_bigendian(1.0d));
Assert.Equal(new byte[] { 0x3f, 0xf1, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a }, PickleUtils.double_to_bytes_bigendian(1.1d));
Assert.Equal(new byte[] { 0x40, 0x93, 0x4a, 0x45, 0x6d, 0x5c, 0xfa, 0xad }, PickleUtils.double_to_bytes_bigendian(1234.5678d));
Assert.Equal(new byte[] { 0x59, 0x8a, 0x42, 0xd1, 0xce, 0xf5, 0x3f, 0x46 }, PickleUtils.double_to_bytes_bigendian(2.17e123d));
Assert.Equal(new byte[] { 0x7e, 0x3d, 0x7e, 0xe8, 0xbc, 0xaf, 0x28, 0x3a }, PickleUtils.double_to_bytes_bigendian(1.23456789e300d));
// cannot test NaN because it's not always the same byte representation...
// Assert.Equal(new byte[]{0xff,0xf8,0,0,0,0,0,0}, p.double_to_bytes(Double.NaN));
Assert.Equal(new byte[] { 0x7f, 0xf0, 0, 0, 0, 0, 0, 0 }, PickleUtils.double_to_bytes_bigendian(double.PositiveInfinity));
Assert.Equal(new byte[] { 0xff, 0xf0, 0, 0, 0, 0, 0, 0 }, PickleUtils.double_to_bytes_bigendian(double.NegativeInfinity));
}
public void testStr2Bytes()
{
byte[] bytes = PickleUtils.str2bytes(STRING256);
for (int i = 0; i < 256; ++i)
{
int b = bytes[i];
if (b < 0)
{
b += 256;
}
Assert.AreEqual(i, b, "byte@" + i);
}
}
public void TestStr2Bytes()
{
var bytes = PickleUtils.str2bytes(STRING256);
for (int i = 0; i < 256; ++i)
{
int b = bytes[i];
if (b < 0)
{
b += 256;
}
Assert.Equal(i, b); //"byte@"+i
}
}
public void testReadline()
{
Stream bis = new MemoryStream(filedata);
Assert.Equal("str1", PickleUtils.readline(bis));
Assert.Equal("str2 ", PickleUtils.readline(bis));
Assert.Equal(" str3 ", PickleUtils.readline(bis));
Assert.Equal("end", PickleUtils.readline(bis));
try
{
PickleUtils.readline(bis);
Assert.True(false, "expected IOException");
}
catch (IOException) {}
}
public void TestReadbytes()
{
Stream bis = new MemoryStream(_filedata);
Assert.Equal(115, PickleUtils.readbyte(bis));
Assert.Equal(new byte[] {}, PickleUtils.readbytes(bis, 0));
Assert.Equal(new byte[] { 116 }, PickleUtils.readbytes(bis, 1));
Assert.Equal(new byte[] { 114, 49, 10, 115, 116 }, PickleUtils.readbytes(bis, 5));
try
{
PickleUtils.readbytes(bis, 999);
Assert.True(false, "expected IOException");
}
catch (IOException) {}
}
public void TestReadlineWithLf()
{
Stream bis = new MemoryStream(_filedata);
Assert.Equal("str1\n", PickleUtils.readline(bis, true));
Assert.Equal("str2 \n", PickleUtils.readline(bis, true));
Assert.Equal(" str3 \n", PickleUtils.readline(bis, true));
Assert.Equal("end", PickleUtils.readline(bis, true));
try
{
PickleUtils.readline(bis, true);
Assert.True(false, "expected IOException");
}
catch (IOException) {}
}
public void TestBytes_to_uint()
{
try {
PickleUtils.bytes_to_uint(new byte[] {}, 0);
Assert.True(false, "expected PickleException");
} catch (PickleException) {}
try {
PickleUtils.bytes_to_uint(new byte[] { 0 }, 0);
Assert.True(false, "expected PickleException");
} catch (PickleException) {}
Assert.Equal(0x000000000L, PickleUtils.bytes_to_uint(new byte[] { 0, 0, 0, 0 }, 0));
Assert.Equal(0x012345678L, PickleUtils.bytes_to_uint(new byte[] { 0x78, 0x56, 0x34, 0x12 }, 0));
Assert.Equal(0x0ff802040L, PickleUtils.bytes_to_uint(new byte[] { 0x40, 0x20, 0x80, 0xff }, 0));
Assert.Equal(0x0eefffffeL, PickleUtils.bytes_to_uint(new byte[] { 0xfe, 0xff, 0xff, 0xee }, 0));
}
public void testReadlineWithLF()
{
Stream bis = new MemoryStream(filedata);
Assert.AreEqual("str1\n", PickleUtils.readline(bis, true));
Assert.AreEqual("str2 \n", PickleUtils.readline(bis, true));
Assert.AreEqual(" str3 \n", PickleUtils.readline(bis, true));
Assert.AreEqual("end", PickleUtils.readline(bis, true));
try
{
PickleUtils.readline(bis, true);
Assert.Fail("expected IOException");
}
catch (IOException) {}
}
public void testReadbytes()
{
Stream bis = new MemoryStream(filedata);
PickleUtils p = new PickleUtils(bis);
Assert.AreEqual(115, p.readbyte());
Assert.AreEqual(new byte[] {}, p.readbytes(0));
Assert.AreEqual(new byte[] { 116 }, p.readbytes(1));
Assert.AreEqual(new byte[] { 114, 49, 10, 115, 116 }, p.readbytes(5));
try
{
p.readbytes(999);
Assert.Fail("expected IOException");
}
catch (IOException) {}
}
public void testReadline()
{
Stream bis = new MemoryStream(filedata);
PickleUtils p = new PickleUtils(bis);
Assert.AreEqual("str1", p.readline());
Assert.AreEqual("str2 ", p.readline());
Assert.AreEqual(" str3 ", p.readline());
Assert.AreEqual("end", p.readline());
try
{
p.readline();
Assert.Fail("expected IOException");
}
catch (IOException) {}
}
public static void Main()
{
Unpickler u=new Unpickler();
Console.WriteLine("here we go; 1");
var data = PickleUtils.str2bytes("\u0080\u0002carray\narray\nq\u0000U\u0001iq\u0001]q\u0002\u0086q\u0003Rq\u0004.");
var result = u.loads(data);
PrettyPrint.print(result);
Console.WriteLine("here we go; 2");
data=PickleUtils.str2bytes("\u0080\u0003carray\n_array_reconstructor\nq\u0000(carray\narray\nq\u0001X\u0001\u0000\u0000\u0000iq\u0002K\u0008C\u000c\u000f'\u0000\u0000\u00b8\"\u0000\u0000a\u001e\u0000\u0000q\u0003tq\u0004Rq\u0005.");
result=u.loads(data);
PrettyPrint.print(result);
Console.Write("Press any key to continue . . . ");
Console.ReadKey(true);
}
