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 SprotoTcpSocket(SprotoMgr S2C, SprotoMgr C2S)
{
this.TcpSocket = new TcpClientSocket();
this.TcpSocket.Register(this._OnConnect, this._OnClose, this._OnMessage, this._Log);
this.Dispatcher = new ProtoDispatcher();
this.Proto = new SprotoRpc(S2C, C2S);
}
public static void Run()
{
Console.WriteLine("TestAll.Run ...");
string proto =
@".foobar {
.nest {
a 1 : string
b 3 : boolean
c 5 : integer
d 6 : integer(3)
}
a 0 : string
b 1 : integer
c 2 : boolean
d 3 : *nest(a)
e 4 : *string
f 5 : *integer
g 6 : *boolean
h 7 : *foobar
i 8 : *integer(2)
j 9 : binary
}
";
SprotoMgr sprotomgr = SprotoParser.Parse(proto);
sprotomgr.Dump();
string filename = "Test/Person.sproto";
SprotoMgr sprotomgr2 = SprotoParser.ParseFile(filename);
sprotomgr2.Dump();
Console.WriteLine("TestAll.Run ok");
}
public SprotoTcpSocket(string s2cfile, string c2sfile, bool isbinary = false)
{
this.TcpSocket = new TcpClientSocket();
this.TcpSocket.Register(this._OnConnect, this._OnClose, this._OnMessage, this._Log);
this.Dispatcher = new ProtoDispatcher();
SprotoMgr S2C = SprotoParser.ParseFile(s2cfile);
SprotoMgr C2S = SprotoParser.ParseFile(c2sfile);
this.Proto = new SprotoRpc(S2C, C2S);
}
public void Run()
{
string c2s =
@"
.package {
type 0 : integer
session 1 : integer
ud 2 : integer
}
C2GS_Ping 1006 {
request {
str 0 : string
}
}
";
string s2c =
@"
.package {
type 0 : integer
session 1 : integer
ud 2 : integer
}
GS2C_Pong 1108 {
request {
str 0 : string
time 1 : integer
}
}
";
SprotoMgr C2S = SprotoParser.Parse(c2s);
SprotoMgr S2C = SprotoParser.Parse(s2c);
SprotoTcpSocket Client = new SprotoTcpSocket(S2C, C2S);
Client.OnConnect += this.OnConnect;
Client.OnClose += this.OnClose;
Client.Log = this.LogSocket;
//string host = "127.0.0.1";
string host = "111.230.108.129";
int port = 8888;
Client.TcpSocket.Connect(host, port);
Client.Dispatcher.AddHandler("GS2C_Pong", this.HandlerLoginPong);
while (true)
{
Client.TcpSocket.Dispatch();
Thread.Sleep(1000);
}
}
public TestTcpClientSocket()
{
string c2s =
@"
.package {
type 0 : integer
session 1 : integer
ud 2 : integer
}
C2GS_Ping 1006 {
request {
str 0 : string
}
}
";
string s2c =
@"
.package {
type 0 : integer
session 1 : integer
ud 2 : integer
}
GS2C_Pong 1108 {
request {
str 0 : string
time 1 : integer
}
}
";
SprotoMgr C2SProto = SprotoParser.Parse(c2s);
SprotoMgr S2CProto = SprotoParser.Parse(s2c);
Proto = new SprotoRpc(S2CProto, C2SProto);
TcpSocket = new TcpClientSocket();
}
public static void Run()
{
string filename = "Test/BenchMark.sproto";
SprotoMgr sprotomgr = SprotoParser.ParseFile(filename);
SprotoObject address = sprotomgr.NewSprotoObject("AddressBook");
SprotoObject person1 = sprotomgr.NewSprotoObject("Person");
person1["name"] = "Alice";
person1["id"] = 10000;
List <SprotoObject> phones = new List <SprotoObject>();
SprotoObject phone1 = sprotomgr.NewSprotoObject("Person.PhoneNumber");
phone1["number"] = "123456789";
phone1["type"] = 1;
SprotoObject phone2 = sprotomgr.NewSprotoObject("Person.PhoneNumber");
phone2["number"] = "87654321";
phone2["type"] = 2;
phones.Add(phone1);
phones.Add(phone2);
person1["phone"] = phones;
SprotoObject person2 = sprotomgr.NewSprotoObject("Person");
person2["name"] = "Bob";
person2["id"] = 20000;
phones = new List <SprotoObject>();
phone1 = sprotomgr.NewSprotoObject("Person.PhoneNumber");
phone1["number"] = "01234567890";
phone1["type"] = 3;
phones.Add(phone1);
person2["phone"] = phones;
List <SprotoObject> persons = new List <SprotoObject>();
persons.Add(person1);
persons.Add(person2);
address["person"] = persons;
int times = 1000000;
SprotoStream writer = new SprotoStream();
sprotomgr.Dump();
Console.WriteLine("benchmark times: {0}", times);
double start = SprotoBenchMark.cur_mssecond();
for (int i = 0; i < times; i++)
{
writer.Seek(0, SprotoStream.SEEK_BEGIN); // clear stream
writer = sprotomgr.Encode(address, writer);
}
double end = SprotoBenchMark.cur_mssecond();
int size = writer.Position;
Console.WriteLine("[Encode] total={0}ms,size={1}byte", end - start, size);
SprotoStream reader = writer;
start = SprotoBenchMark.cur_mssecond();
for (int i = 0; i < times; i++)
{
reader.Seek(0, SprotoStream.SEEK_BEGIN);
sprotomgr.Decode("AddressBook", reader);
}
end = SprotoBenchMark.cur_mssecond();
Console.WriteLine("[Decode] total={0}ms", end - start);
byte[] bin = null;
size = 0;
start = SprotoBenchMark.cur_mssecond();
for (int i = 0; i < times; i++)
{
writer.Seek(0, SprotoStream.SEEK_BEGIN);
bin = sprotomgr.PackEncode(address, out size, writer);
}
end = SprotoBenchMark.cur_mssecond();
Console.WriteLine("[PackEncode] total={0}ms,size={1}byte", end - start, size);
start = SprotoBenchMark.cur_mssecond();
for (int i = 0; i < times; i++)
{
sprotomgr.UnpackDecode("AddressBook", bin, 0, size);
}
end = SprotoBenchMark.cur_mssecond();
Console.WriteLine("[UnpackDecode] total={0}ms", end - start);
}
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 void Run(SprotoTcpSocket.LogType log)
{
// string c2s =
//@"
//.package {
// type 0 : integer
// session 1 : integer
// ud 2 : integer
//}
//
//C2GS_Ping 1006 {
// request {
// str 0 : string
// }
//}
//";
// string s2c =
//@"
//.package {
// type 0 : integer
// session 1 : integer
// ud 2 : integer
//}
//
//GS2C_Pong 1108 {
// request {
// str 0 : string
// time 1 : integer
// }
//}
//";
string c2s =
@"
.package {
type 0 : integer
session 1 : integer
}
handshake 1 {
response {
msg 0 : string
}
}
get 2 {
request {
what 0 : string
}
response {
result 0 : string
}
}
set 3 {
request {
what 0 : string
value 1 : string
}
}
quit 4 {}
complex 5 {
request {
}
response {
}
}
";
string s2c =
@"
.package {
type 0 : integer
session 1 : integer
}
heartbeat 1 {}
";
_log = log;
SprotoMgr C2S = SprotoParser.Parse(c2s);
SprotoMgr S2C = SprotoParser.Parse(s2c);
// foreach (string key in C2S.Types.Keys)
// {
// log(key);
// }
SprotoTcpSocket client = new SprotoTcpSocket(S2C, C2S);
client.OnConnect += this.OnConnect;
client.OnClose += this.OnClose;
client.Log = log;
string host = "127.0.0.1";
// string host = "111.230.108.129";
int port = 8888;
client.TcpSocket.Connect(host, port);
client.Dispatcher.AddHandler("heartbeat", HandleHeartBeat);
while (true)
{
client.TcpSocket.Dispatch();
Thread.Sleep(100);
}
}
public static void Run()
{
string c2s =
@"
.package {
type 0 : integer
session 1 : integer
}
.Person {
id 0 : integer # int type
name 1 : string # string type
age 2 : integer # int type
isman 3 : boolean # bool type
emails 4 : *string # string list
children 5 : *Person # Person list
luckydays 6 : *integer # integer list
}
get 1 {
request {
id 0 : integer
}
response Person
}
";
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);
// create a request
SprotoObject request = Client.C2S.NewSprotoObject("get.request");
request["id"] = 1;
RpcPackage request_package = Client.PackRequest("get", request, 1);
RpcMessage message = Server.UnpackMessage(request_package.data, request_package.size);
// create a response
//SprotoObject response = Client.C2S.NewSprotoObject("Person");
SprotoObject response = Server.S2C.NewSprotoObject("Person");
response["id"] = 1;
response["name"] = "sundream";
response["age"] = 26;
response["emails"] = new List <string> {
"*****@*****.**",
};
//List<SprotoObject> children = new List<SprotoObject>();
// no children
//response["children"] = children;
response["luckydays"] = new List <Int64> {
0, 6
};
RpcPackage response_package = Server.PackResponse("get", response, 1);
message = Client.UnpackMessage(response_package.data, response_package.size);
Console.WriteLine("proto={0},tag={1},ud={2},session={3},type={4},request={5},response={6}",
message.proto, message.tag, message.ud, message.session, message.type, message.request, message.response);
}
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");
}
