public static void Run()
{
Console.WriteLine("TestSprotoParser.Run ...");
string filename = "Test/TestAll.sproto";
SprotoMgr sproto = SprotoParser.ParseFile(filename);
//sproto.Dump();
byte[] bin = SprotoParser.DumpToBinary(sproto);
//SprotoHelper.PrintBytes(bin,0,bin.Length);
filename = "Test/TestAll.spb";
SprotoMgr sproto2 = SprotoParser.ParseFromBinaryFile(filename);
sproto2.Dump();
byte[] bin2 = SprotoParser.DumpToBinary(sproto2);
//SprotoHelper.PrintBytes(bin2,0,bin2.Length);
bool ok = bin.Length == bin2.Length;
SprotoHelper.Assert(ok);
for (int i = 0; i < bin.Length; i++)
{
if (bin[i] != bin2[i])
{
ok = false;
break;
}
}
SprotoHelper.Assert(ok);
Console.WriteLine("TestSprotoParser.Run ok");
}
public static void Run()
{
Console.WriteLine("TestSprotoRpc.Run ...");
string c2s =
@".package {
type 0 : integer
session 1 : integer
}
foobar 1 {
request {
what 0 : string
}
response {
ok 0 : boolean
}
}
foo 2 {
response {
ok 0 : boolean
}
}
bar 3 {
response nil
}
blackhole 4 {
}
";
string s2c =
@".package {
type 0 : integer
session 1 : integer
}
";
SprotoMgr S2C = SprotoParser.Parse(s2c);
SprotoMgr C2S = SprotoParser.Parse(c2s);
SprotoRpc Client = new SprotoRpc(S2C, C2S);
SprotoRpc Server = new SprotoRpc(C2S, S2C);
// test proto foobar
SprotoObject request = Client.C2S.NewSprotoObject("foobar.request");
request["what"] = "foo";
RpcPackage request_package = Client.PackRequest("foobar", request, 1);
Console.WriteLine("Client request foobar: data={0},size={1}", request_package.data, request_package.size);
RpcMessage message = Server.UnpackMessage(request_package.data, request_package.size);
SprotoHelper.Assert(message.proto == "foobar");
SprotoHelper.Assert(message.type == "request", "not a request");
SprotoHelper.Assert(message.request != null);
SprotoHelper.Assert(message.request["what"] == "foo");
SprotoHelper.Assert(message.session == 1);
SprotoObject response = Client.C2S.NewSprotoObject("foobar.response");
response["ok"] = true;
RpcPackage response_package = Server.PackResponse(message.proto, response, message.session);
Console.WriteLine("Server resonse foobar: data={0},size={1}", response_package.data, response_package.size);
message = Client.UnpackMessage(response_package.data, response_package.size);
SprotoHelper.Assert(message.proto == "foobar");
SprotoHelper.Assert(message.type == "response", "not a response");
SprotoHelper.Assert(message.response != null);
SprotoHelper.Assert(message.response["ok"] == true);
SprotoHelper.Assert(message.session == 1);
// test proto foo
request_package = Client.PackRequest("foo", null, 2);
Console.WriteLine("Client request foo: data={0},size={1}", request_package.data, request_package.size);
message = Server.UnpackMessage(request_package.data, request_package.size);
SprotoHelper.Assert(message.proto == "foo");
SprotoHelper.Assert(message.type == "request", "not a request");
SprotoHelper.Assert(message.request == null); // no request data
SprotoHelper.Assert(message.session == 2);
response = Client.C2S.NewSprotoObject("foo.response");
response["ok"] = false;
response_package = Server.PackResponse(message.proto, response, message.session);
Console.WriteLine("Server resonse foo: data={0},size={1}", response_package.data, response_package.size);
message = Client.UnpackMessage(response_package.data, response_package.size);
SprotoHelper.Assert(message.proto == "foo");
SprotoHelper.Assert(message.type == "response", "not a response");
SprotoHelper.Assert(message.response != null);
SprotoHelper.Assert(message.response["ok"] == false);
SprotoHelper.Assert(message.session == 2);
// test proto bar
request_package = Client.PackRequest("bar", null, 3);
Console.WriteLine("Client request bar: data={0},size={1}", request_package.data, request_package.size);
message = Server.UnpackMessage(request_package.data, request_package.size);
SprotoHelper.Assert(message.proto == "bar");
SprotoHelper.Assert(message.type == "request", "not a request");
SprotoHelper.Assert(message.request == null); // no request data
SprotoHelper.Assert(message.session == 3);
response_package = Server.PackResponse(message.proto, null, message.session);
Console.WriteLine("Server resonse bar: data={0},size={1}", response_package.data, response_package.size);
message = Client.UnpackMessage(response_package.data, response_package.size);
SprotoHelper.Assert(message.proto == "bar");
SprotoHelper.Assert(message.type == "response", "not a response");
SprotoHelper.Assert(message.response == null); // no response data
SprotoHelper.Assert(message.session == 3);
// test proto blackhole
request_package = Client.PackRequest("blackhole", null, 0);
Console.WriteLine("Client request blackhole: data={0},size={1}", request_package.data, request_package.size);
message = Server.UnpackMessage(request_package.data, request_package.size);
SprotoHelper.Assert(message.proto == "blackhole");
SprotoHelper.Assert(message.type == "request", "not a request");
SprotoHelper.Assert(message.request == null); // no request data
SprotoHelper.Assert(message.session == 0);
// session == 0 mean: can donn't response
Client.C2S.Dump();
Console.WriteLine("TestSprotoRpc.Run ok");
}
public static void Run()
{
Console.WriteLine("TestSprotoCodec.Run ...");
// see https://github.com/cloudwu/sproto
string filename = "Test/Person.sproto";
SprotoMgr sproto = SprotoParser.ParseFile(filename);
Console.WriteLine("=====example 1=====");
SprotoObject obj = sproto.NewSprotoObject("Person");
obj["name"] = "Alice";
obj["age"] = 13;
obj["marital"] = false;
SprotoObject data = sproto.NewSprotoObject("Data");
data["number"] = 1;
obj["data"] = data;
byte[] expect_bytes =
{
0x05, 0x00,
0x00, 0x00,
0x1c, 0x00,
0x02, 0x00,
0x01, 0x00,// (skip id=3)
0x00, 0x00,
0x05, 0x00, 0x00, 0x00,
0x41, 0x6c, 0x69, 0x63, 0x65,
// Data field
0x06, 0x00, 0x00, 0x00,
0x02, 0x00,
0x03, 0x00,
0x04, 0x00,
};
SprotoStream encode_stream = sproto.Encode(obj);
int length = encode_stream.Position;
SprotoHelper.PrintBytes(encode_stream.Buffer, 0, length);
bool ok = true;
for (int i = 0; i < length; i++)
{
if (encode_stream.Buffer[i] != expect_bytes[i])
{
ok = false;
break;
}
}
SprotoHelper.Assert(ok);
SprotoStream decode_stream = encode_stream;
decode_stream.Seek(0, SprotoStream.SEEK_BEGIN);
Console.WriteLine("decode_stream.Position:{0}", decode_stream.Position);
//SprotoHelper.PrintBytes(decode_stream.Buffer,0,length);
SprotoObject decode_obj = sproto.Decode("Person", decode_stream);
SprotoHelper.Assert(decode_stream.Position == length);
SprotoHelper.Assert(decode_obj["name"] == "Alice");
SprotoHelper.Assert(decode_obj["age"] == 13);
SprotoHelper.Assert(decode_obj["marital"] == false);
SprotoHelper.Assert(decode_obj["children"] == null);
SprotoObject decode_data = decode_obj["data"];
SprotoHelper.Assert(decode_data["number"] == 1);
Console.WriteLine("=====example 2=====");
obj = sproto.NewSprotoObject("Person");
List <SprotoObject> children = new List <SprotoObject>();
SprotoObject child1 = sproto.NewSprotoObject("Person");
child1["name"] = "Alice";
child1["age"] = 13;
SprotoObject child2 = sproto.NewSprotoObject("Person");
child2["name"] = "Carol";
child2["age"] = 5;
children.Add(child1);
children.Add(child2);
obj["name"] = "Bob";
obj["age"] = 40;
obj["children"] = children;
expect_bytes = new byte[] {
0x04, 0x00,
0x00, 0x00,
0x52, 0x00,
0x01, 0x00,
0x00, 0x00,
0x03, 0x00, 0x00, 0x00,
0x42, 0x6f, 0x62,
0x26, 0x00, 0x00, 0x00,
0x0f, 0x00, 0x00, 0x00,
0x02, 0x00,
0x00, 0x00,
0x1c, 0x00,
0x05, 0x00, 0x00, 0x00,
0x41, 0x6c, 0x69, 0x63, 0x65,
0x0f, 0x00, 0x00, 0x00,
0x02, 0x00,
0x00, 0x00,
0x0c, 0x00,
0x05, 0x00, 0x00, 0x00,
0x43, 0x61, 0x72, 0x6f, 0x6c,
};
encode_stream = sproto.Encode(obj);
length = encode_stream.Position;
SprotoHelper.PrintBytes(encode_stream.Buffer, 0, length);
ok = true;
for (int i = 0; i < length; i++)
{
if (encode_stream.Buffer[i] != expect_bytes[i])
{
ok = false;
break;
}
}
SprotoHelper.Assert(ok);
decode_stream = encode_stream;
decode_stream.Seek(0, SprotoStream.SEEK_BEGIN);
Console.WriteLine("decode_stream.Position:{0}", decode_stream.Position);
//SprotoHelper.PrintBytes(decode_stream.Buffer,0,length);
decode_obj = sproto.Decode("Person", decode_stream);
SprotoHelper.Assert(decode_stream.Position == length);
SprotoHelper.Assert(decode_obj["name"] == "Bob");
SprotoHelper.Assert(decode_obj["age"] == 40);
SprotoHelper.Assert(decode_obj["marital"] == null);
List <SprotoObject> decode_children = decode_obj["children"];
SprotoHelper.Assert(decode_children != null);
SprotoHelper.Assert(decode_children.Count == 2);
SprotoObject decode_child1 = decode_children[0];
SprotoObject decode_child2 = decode_children[1];
SprotoHelper.Assert(child1["name"] == "Alice");
SprotoHelper.Assert(child1["age"] == 13);
SprotoHelper.Assert(child2["name"] == "Carol");
SprotoHelper.Assert(child2["age"] == 5);
Console.WriteLine("=====example 3=====");
obj = sproto.NewSprotoObject("Data");
List <Int64> numbers = new List <Int64> {
1, 2, 3, 4, 5
};
obj["numbers"] = numbers;
expect_bytes = new byte[] {
0x01, 0x00,
0x00, 0x00,
0x15, 0x00, 0x00, 0x00,
0x04,
0x01, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00,
0x03, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00,
0x05, 0x00, 0x00, 0x00,
};
encode_stream = sproto.Encode(obj);
length = encode_stream.Position;
SprotoHelper.PrintBytes(encode_stream.Buffer, 0, length);
ok = true;
for (int i = 0; i < length; i++)
{
if (encode_stream.Buffer[i] != expect_bytes[i])
{
ok = false;
break;
}
}
SprotoHelper.Assert(ok);
decode_stream = encode_stream;
decode_stream.Seek(0, SprotoStream.SEEK_BEGIN);
Console.WriteLine("decode_stream.Position:{0}", decode_stream.Position);
//SprotoHelper.PrintBytes(decode_stream.Buffer,0,length);
decode_obj = sproto.Decode("Data", decode_stream);
SprotoHelper.Assert(decode_stream.Position == length);
List <Int64> decode_numbers = decode_obj["numbers"];
SprotoHelper.Assert(decode_numbers.Count == numbers.Count);
for (int i = 0; i < decode_numbers.Count; i++)
{
SprotoHelper.Assert(numbers[i] == decode_numbers[i]);
}
Console.WriteLine("=====example 4=====");
obj = sproto.NewSprotoObject("Data");
numbers = new List <Int64> {
(Int64)((1ul << 32) + 1),
(Int64)((1ul << 32) + 2),
(Int64)((1ul << 32) + 3),
};
obj["numbers"] = numbers;
expect_bytes = new byte[] {
0x01, 0x00,
0x00, 0x00,
0x19, 0x00, 0x00, 0x00,
0x08,
0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
};
encode_stream = sproto.Encode(obj);
length = encode_stream.Position;
SprotoHelper.PrintBytes(encode_stream.Buffer, 0, length);
ok = true;
for (int i = 0; i < length; i++)
{
if (encode_stream.Buffer[i] != expect_bytes[i])
{
ok = false;
break;
}
}
SprotoHelper.Assert(ok);
decode_stream = encode_stream;
decode_stream.Seek(0, SprotoStream.SEEK_BEGIN);
Console.WriteLine("decode_stream.Position:{0}", decode_stream.Position);
//SprotoHelper.PrintBytes(decode_stream.Buffer,0,length);
decode_obj = sproto.Decode("Data", decode_stream);
SprotoHelper.Assert(decode_stream.Position == length);
decode_numbers = decode_obj["numbers"];
SprotoHelper.Assert(decode_numbers.Count == numbers.Count);
for (int i = 0; i < decode_numbers.Count; i++)
{
SprotoHelper.Assert(numbers[i] == decode_numbers[i]);
}
Console.WriteLine("=====example 5=====");
obj = sproto.NewSprotoObject("Data");
List <bool> bools = new List <bool> {
false, true, false
};
obj["bools"] = bools;
expect_bytes = new byte[] {
0x02, 0x00,
0x01, 0x00,
0x00, 0x00,
0x03, 0x00, 0x00, 0x00,
0x00,
0x01,
0x00,
};
encode_stream = sproto.Encode(obj);
length = encode_stream.Position;
SprotoHelper.PrintBytes(encode_stream.Buffer, 0, length);
ok = true;
for (int i = 0; i < length; i++)
{
if (encode_stream.Buffer[i] != expect_bytes[i])
{
ok = false;
break;
}
}
SprotoHelper.Assert(ok);
decode_stream = encode_stream;
decode_stream.Seek(0, SprotoStream.SEEK_BEGIN);
Console.WriteLine("decode_stream.Position:{0}", decode_stream.Position);
//SprotoHelper.PrintBytes(decode_stream.Buffer,0,length);
decode_obj = sproto.Decode("Data", decode_stream);
SprotoHelper.Assert(decode_stream.Position == length);
List <bool> decode_bools = decode_obj["bools"];
SprotoHelper.Assert(decode_bools.Count == bools.Count);
for (int i = 0; i < decode_bools.Count; i++)
{
SprotoHelper.Assert(bools[i] == decode_bools[i]);
}
Console.WriteLine("=====example 6=====");
obj = sproto.NewSprotoObject("Data");
obj["number"] = 100000;
obj["bignumber"] = -10000000000;
expect_bytes = new byte[] {
0x03, 0x00,
0x03, 0x00,
0x00, 0x00,
0x00, 0x00,
0x04, 0x00, 0x00, 0x00,
0xa0, 0x86, 0x01, 0x00,
0x08, 0x00, 0x00, 0x00,
0x00, 0x1c, 0xf4, 0xab, 0xfd, 0xff, 0xff, 0xff,
};
encode_stream = sproto.Encode(obj);
length = encode_stream.Position;
SprotoHelper.PrintBytes(encode_stream.Buffer, 0, length);
ok = true;
for (int i = 0; i < length; i++)
{
if (encode_stream.Buffer[i] != expect_bytes[i])
{
ok = false;
break;
}
}
SprotoHelper.Assert(ok);
decode_stream = encode_stream;
decode_stream.Seek(0, SprotoStream.SEEK_BEGIN);
Console.WriteLine("decode_stream.Position:{0}", decode_stream.Position);
//SprotoHelper.PrintBytes(decode_stream.Buffer,0,length);
decode_obj = sproto.Decode("Data", decode_stream);
SprotoHelper.Assert(decode_stream.Position == length);
Int64 decode_number = decode_obj["number"];
Int64 decode_bignumber = decode_obj["bignumber"];
SprotoHelper.Assert(decode_number == obj["number"]);
SprotoHelper.Assert(decode_bignumber == obj["bignumber"]);
Console.WriteLine("TestSprotoCodec.Run ok");
}
public static void Run()
{
Console.WriteLine("TestSprotoObject.Run ...");
string filename = "Test/TestAll.sproto";
SprotoMgr sproto = SprotoParser.ParseFile(filename);
var foobar = sproto.NewSprotoObject("foobar");
foobar["a"] = "hello";
foobar["b"] = 100;
foobar["c"] = true;
var nest = sproto.NewSprotoObject("foobar.nest");
nest["a"] = "hello";
nest["b"] = true;
nest["c"] = 100;
Dictionary <string, SprotoObject> nestDict = new Dictionary <string, SprotoObject>();
nestDict.Add(nest["a"], nest);
foobar["d"] = nestDict;
List <string> strList = new List <string>();
strList.Add("hello");
strList.Add("world");
foobar["e"] = strList;
List <Int64> intList = new List <Int64>();
intList.Add(1);
intList.Add(2);
intList.Add(3);
foobar["f"] = intList;
List <bool> boolList = new List <bool>();
boolList.Add(true);
boolList.Add(false);
foobar["g"] = boolList;
List <SprotoObject> foobarList = new List <SprotoObject>();
// null foobar2
SprotoObject foobar2 = sproto.NewSprotoObject("foobar");
foobarList.Add(foobar2);
foobar["h"] = foobarList;
List <double> doubleList = new List <double>();
doubleList.Add(1.355);
doubleList.Add(1.354);
foobar["i"] = doubleList;
byte[] binary = Encoding.UTF8.GetBytes("abcdef");
foobar["j"] = binary;
foobar.Dump();
SprotoHelper.Assert(foobar["a"] == "hello");
SprotoHelper.Assert(foobar["b"] == 100);
SprotoHelper.Assert(foobar["c"] == true);
Dictionary <string, SprotoObject> expect_d = foobar["d"];
SprotoHelper.Assert(expect_d.Count == 1);
SprotoHelper.Assert(expect_d["hello"]["a"] == "hello");
SprotoHelper.Assert(expect_d["hello"]["b"] == true);
SprotoHelper.Assert(expect_d["hello"]["c"] == 100);
List <string> expect_e = foobar["e"];
SprotoHelper.Assert(expect_e.Count == 2);
SprotoHelper.Assert(expect_e[0] == "hello");
SprotoHelper.Assert(expect_e[1] == "world");
List <Int64> expect_f = foobar["f"];
SprotoHelper.Assert(expect_f.Count == 3);
SprotoHelper.Assert(expect_f[0] == 1);
SprotoHelper.Assert(expect_f[1] == 2);
SprotoHelper.Assert(expect_f[2] == 3);
List <bool> expect_g = foobar["g"];
SprotoHelper.Assert(expect_g.Count == 2);
SprotoHelper.Assert(expect_g[0] == true);
SprotoHelper.Assert(expect_g[1] == false);
List <SprotoObject> expect_h = foobar["h"];
SprotoHelper.Assert(expect_h.Count == 1);
SprotoHelper.Assert(expect_h[0].val == null);
List <double> expect_i = foobar["i"];
SprotoHelper.Assert(expect_i[0] == 1.355);
SprotoHelper.Assert(expect_i[1] == 1.354);
byte[] expect_j = foobar["j"];
bool ok = true;
for (int i = 0; i < expect_j.Length; i++)
{
if (expect_j[i] != binary[i])
{
ok = false;
break;
}
}
SprotoHelper.Assert(ok);
// encode/decode
SprotoStream encode_stream = sproto.Encode(foobar);
int length = encode_stream.Position;
SprotoStream decode_stream = encode_stream;
decode_stream.Seek(0, SprotoStream.SEEK_BEGIN);
SprotoObject decode_foobar = sproto.Decode("foobar", decode_stream);
decode_foobar.Dump();
SprotoHelper.Assert(decode_foobar["a"] == "hello");
SprotoHelper.Assert(decode_foobar["b"] == 100);
SprotoHelper.Assert(decode_foobar["c"] == true);
expect_d = decode_foobar["d"];
SprotoHelper.Assert(expect_d.Count == 1);
SprotoHelper.Assert(expect_d["hello"]["a"] == "hello");
SprotoHelper.Assert(expect_d["hello"]["b"] == true);
SprotoHelper.Assert(expect_d["hello"]["c"] == 100);
expect_e = decode_foobar["e"];
SprotoHelper.Assert(expect_e.Count == 2);
SprotoHelper.Assert(expect_e[0] == "hello");
SprotoHelper.Assert(expect_e[1] == "world");
expect_f = decode_foobar["f"];
SprotoHelper.Assert(expect_f.Count == 3);
SprotoHelper.Assert(expect_f[0] == 1);
SprotoHelper.Assert(expect_f[1] == 2);
SprotoHelper.Assert(expect_f[2] == 3);
expect_g = decode_foobar["g"];
SprotoHelper.Assert(expect_g.Count == 2);
SprotoHelper.Assert(expect_g[0] == true);
SprotoHelper.Assert(expect_g[1] == false);
expect_h = decode_foobar["h"];
SprotoHelper.Assert(expect_h.Count == 1);
SprotoHelper.Assert(expect_h[0].val == null);
expect_i = decode_foobar["i"];
SprotoHelper.Assert(expect_i[0] == 1.36);
SprotoHelper.Assert(expect_i[1] == 1.35);
expect_j = decode_foobar["j"];
ok = true;
for (int i = 0; i < expect_j.Length; i++)
{
if (expect_j[i] != binary[i])
{
ok = false;
break;
}
}
SprotoHelper.Assert(ok);
Console.WriteLine("TestSprotoObject.Run ok");
}
public static void Run()
{
Console.WriteLine("TestSprotoPacker.Run ...");
SprotoPacker packer = new SprotoPacker();
Console.WriteLine("=====example 1=====");
byte[] input =
{
0x08, 0x00, 0x00, 0x00, 0x03, 0x00, 0x02, 0x00,
0x19, 0x00, 0x00, 0x00, 0xaa, 0x01, 0x00, 0x00,
};
byte[] expect =
{
0x51, 0x08, 0x03, 0x02,
0x31, 0x19, 0xaa, 0x01,
};
int pack_size = 0;
byte[] pack_output = packer.Pack(input, 0, input.Length, out pack_size);
SprotoHelper.PrintBytes(pack_output, 0, pack_size);
SprotoHelper.Assert(pack_size == expect.Length);
bool ok = true;
for (int i = 0; i < pack_size; i++)
{
if (pack_output[i] != expect[i])
{
ok = false;
break;
}
}
SprotoHelper.Assert(ok);
int unpack_size = 0;
byte[] unpack_output = packer.Unpack(pack_output, 0, pack_size, out unpack_size);
SprotoHelper.Assert(unpack_size == input.Length);
ok = true;
for (int i = 0; i < input.Length; i++)
{
if (input[i] != unpack_output[i])
{
ok = false;
break;
}
}
SprotoHelper.Assert(ok);
Console.WriteLine("=====example 2=====");
input = new byte[30];
for (int i = 0; i < input.Length; i++)
{
input[i] = 0x8a;
}
expect = new byte[2 + 32];
expect[0] = 0xff;
expect[1] = 0x03;
for (int i = 0; i < input.Length; i++)
{
expect[2 + i] = 0x8a;
}
expect[input.Length + 2] = 0x00;
expect[input.Length + 3] = 0x00;
pack_size = 0;
pack_output = packer.Pack(input, 0, input.Length, out pack_size);
SprotoHelper.PrintBytes(pack_output, 0, pack_size);
SprotoHelper.Assert(pack_size == expect.Length);
ok = true;
for (int i = 0; i < pack_size; i++)
{
if (pack_output[i] != expect[i])
{
ok = false;
break;
}
}
SprotoHelper.Assert(ok);
unpack_size = 0;
unpack_output = packer.Unpack(pack_output, 0, pack_size, out unpack_size);
//SprotoHelper.PrintBytes(unpack_output,0,unpack_size);
// 30 byte expand to 32 byte
SprotoHelper.Assert(unpack_size == input.Length + 2);
ok = true;
for (int i = 0; i < input.Length; i++)
{
if (input[i] != unpack_output[i])
{
ok = false;
break;
}
}
for (int i = input.Length; i < unpack_size; i++)
{
if (unpack_output[i] != 0)
{
ok = false;
break;
}
}
SprotoHelper.Assert(ok);
// best case
Console.WriteLine("=====example 3=====");
int length = 2048;
input = new byte[length];
for (int i = 0; i < input.Length; i++)
{
input[i] = 0x00;
}
expect = new byte[length / 8];
for (int i = 0; i < expect.Length; i++)
{
expect[i] = 0x00;
}
pack_size = 0;
pack_output = packer.Pack(input, 0, input.Length, out pack_size);
SprotoHelper.PrintBytes(pack_output, 0, pack_size);
SprotoHelper.Assert(pack_size == expect.Length);
ok = true;
for (int i = 0; i < pack_size; i++)
{
if (pack_output[i] != expect[i])
{
ok = false;
break;
}
}
SprotoHelper.Assert(ok);
unpack_size = 0;
unpack_output = packer.Unpack(pack_output, 0, pack_size, out unpack_size);
SprotoHelper.Assert(unpack_size == input.Length);
ok = true;
for (int i = 0; i < unpack_size; i++)
{
if (input[i] != unpack_output[i])
{
ok = false;
break;
}
}
SprotoHelper.Assert(ok);
// worst case
Console.WriteLine("=====example 4=====");
length = 2048;
input = new byte[length];
for (int i = 0; i < input.Length; i++)
{
input[i] = 0x11;
}
expect = new byte[length + 2];
expect[0] = 0xff;
expect[1] = (byte)(length / 8 - 1);
for (int i = 0; i < input.Length; i++)
{
expect[2 + i] = 0x11;
}
pack_size = 0;
pack_output = packer.Pack(input, 0, input.Length, out pack_size);
SprotoHelper.PrintBytes(pack_output, 0, pack_size);
SprotoHelper.Assert(pack_size == expect.Length);
ok = true;
for (int i = 0; i < pack_size; i++)
{
if (pack_output[i] != expect[i])
{
ok = false;
break;
}
}
SprotoHelper.Assert(ok);
unpack_size = 0;
unpack_output = packer.Unpack(pack_output, 0, pack_size, out unpack_size);
SprotoHelper.Assert(unpack_size == input.Length);
ok = true;
for (int i = 0; i < unpack_size; i++)
{
if (input[i] != unpack_output[i])
{
ok = false;
break;
}
}
SprotoHelper.Assert(ok);
// part worst case
Console.WriteLine("=====example 5=====");
length = 2048 + 2;
input = new byte[length];
for (int i = 0; i < length - 2; i++)
{
input[i] = 0x11;
}
input[length - 2] = 0x00;
input[length - 1] = 0x01;
expect = new byte[2048 + 4];
expect[0] = 0xff;
expect[1] = (byte)((length - 2) / 8 - 1);
for (int i = 0; i < length - 2; i++)
{
expect[2 + i] = 0x11;
}
expect[length + 0] = 0x02;
expect[length + 1] = 0x01;
pack_size = 0;
pack_output = packer.Pack(input, 0, input.Length, out pack_size);
SprotoHelper.PrintBytes(pack_output, 0, pack_size);
SprotoHelper.Assert(pack_size == expect.Length);
int need_length = SprotoPacker.NeedBufferSize("pack", length);
SprotoHelper.Assert(need_length >= expect.Length);
ok = true;
for (int i = 0; i < pack_size; i++)
{
if (pack_output[i] != expect[i])
{
ok = false;
break;
}
}
SprotoHelper.Assert(ok);
unpack_size = 0;
unpack_output = packer.Unpack(pack_output, 0, pack_size, out unpack_size);
// 2048+2 byte expand to 2048+8 byte
SprotoHelper.Assert(unpack_size == input.Length + 6);
ok = true;
for (int i = 0; i < input.Length; i++)
{
if (input[i] != unpack_output[i])
{
ok = false;
break;
}
}
for (int i = input.Length; i < unpack_size; i++)
{
if (unpack_output[i] != 0)
{
ok = false;
break;
}
}
SprotoHelper.Assert(ok);
Console.WriteLine("TestSprotoPacker.Run ok");
}
