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"); }