public void JsonObjectSerialization()
{
object o = new
{
aNumber = 1,
aString = "2",
anObject = new
{
aNumber = 3,
aString = "4"
},
anArray = new object[]
{
5,
"6",
true,
null,
new
{
aNumber = 7,
aString = "8"
}
}
};
string json = JsonTableConverter.ObjectToJson(o);
Table t = JsonTableConverter.ParseString(json).Table;
AssertTableValues(t);
}
protected virtual void SendMessage(ProtocolMessage message)
{
message.seq = _sequenceNumber++;
if (TRACE_RESPONSE && message.type == "response")
{
Console.Error.WriteLine(string.Format(" R: {0}", JsonTableConverter.ObjectToJson(message)));
}
if (TRACE && message.type == "event")
{
Event e = (Event)message;
Console.Error.WriteLine(string.Format("E {0}: {1}", e.@event, JsonTableConverter.ObjectToJson(e.body)));
}
var data = ConvertToBytes(message);
try
{
_outputStream.Write(data, 0, data.Length);
_outputStream.Flush();
}
catch (Exception)
{
// ignore
}
}
public void JsonObjectSerialization()
{
object o = new
{
aNumber = 1,
aString = "2",
anObject = new
{
aNumber = 3,
aString = "4"
},
anArray = new object[]
{
5,
"6",
true,
null,
new
{
aNumber = 7,
aString = "8"
}
},
aNegativeNumber = -9,
slash = "a/b"
};
string json = JsonTableConverter.ObjectToJson(o);
Table t = JsonTableConverter.JsonToTable(json);
AssertTableValues(t);
}
public void JsonRootEmptyArray()
{
object[] a = new object[] {};
string json = JsonTableConverter.ObjectToJson(a);
DynValue v = JsonTableConverter.ParseString(json, null, true);
Assert.True(JsonEmptyArray.IsJsonEmptyArray(v));
}
public static DynValue serialize(ScriptExecutionContext executionContext, CallbackArguments args)
{
try
{
string s = JsonTableConverter.ObjectToJson(args[0]);
return(DynValue.NewString(s));
}
catch (SyntaxErrorException ex)
{
throw new ScriptRuntimeException(ex);
}
}
public static DynValue parse(ScriptExecutionContext executionContext, CallbackArguments args)
{
try
{
DynValue vs = args.AsType(0, "parse", DataType.String, false);
DynValue parseEmptyArrays = args.AsType(1, "parse", DataType.Boolean, false);
return(JsonTableConverter.ParseString(vs.String, executionContext.GetScript(), parseEmptyArrays.Boolean));
}
catch (SyntaxErrorException ex)
{
throw new ScriptRuntimeException(ex);
}
}
public static DynValue parse(ScriptExecutionContext executionContext, CallbackArguments args)
{
try
{
var vs = args.AsType(0, "parse", DataType.String);
var t = JsonTableConverter.JsonToTable(vs.String, executionContext.GetScript());
return(DynValue.NewTable(t));
}
catch (SyntaxErrorException ex)
{
throw new ScriptRuntimeException(ex);
}
}
public static DynValue serialize(ScriptExecutionContext executionContext, CallbackArguments args)
{
try
{
DynValue vt = args.AsType(0, "serialize", DataType.Table, false);
string s = JsonTableConverter.TableToJson(vt.Table);
return(DynValue.NewString(s));
}
catch (SyntaxErrorException ex)
{
throw new ScriptRuntimeException(ex);
}
}
public void JsonDeserialization()
{
string json = @"{
'aNumber' : 1,
'aString' : '2',
'anObject' : { 'aNumber' : 3, 'aString' : '4' },
'anArray' : [ 5, '6', true, null, { 'aNumber' : 7, 'aString' : '8' } ]
}
" .Replace('\'', '\"');
Table t = JsonTableConverter.ParseString(json).Table;
AssertTableValues(t);
}
public void JsonEmptyArrayDefaultToTable()
{
object o = new
{
anEmptyArray = new object[] {},
};
string json = JsonTableConverter.ObjectToJson(o);
Table t = JsonTableConverter.ParseString(json).Table;
Assert.AreEqual(DataType.Table, t.Get("anEmptyArray").Type);
}
private static byte[] ConvertToBytes(ProtocolMessage request)
{
var asJson = JsonTableConverter.ObjectToJson(request);
byte[] jsonBytes = Encoding.GetBytes(asJson);
string header = string.Format("Content-Length: {0}{1}", jsonBytes.Length, TWO_CRLF);
byte[] headerBytes = Encoding.GetBytes(header);
byte[] data = new byte[headerBytes.Length + jsonBytes.Length];
System.Buffer.BlockCopy(headerBytes, 0, data, 0, headerBytes.Length);
System.Buffer.BlockCopy(jsonBytes, 0, data, headerBytes.Length, jsonBytes.Length);
return(data);
}
public void JsonDeserialization()
{
string json = @"{
'aNumber' : 1,
'aString' : '2',
'anObject' : { 'aNumber' : 3, 'aString' : '4' },
'anArray' : [ 5, '6', true, null, { 'aNumber' : 7, 'aString' : '8' } ],
'aNegativeNumber' : -9,
'slash' : 'a\/b'
}
" .Replace('\'', '\"');
Table t = JsonTableConverter.JsonToTable(json);
AssertTableValues(t);
}
private static ScriptZoneGeneratorSettings GenerateSettings(Script script, string settings)
{
Table settingsTable = JsonTableConverter.JsonToTable(settings, script);
Table fallbackTable = settingsTable.Get(DynValue.NewString("fallback")).Table;
ScriptZoneLevelSettings fallback = new ScriptZoneLevelSettings(fallbackTable);
Table entriesTable = settingsTable.Get(DynValue.NewString("entries")).Table;
List <ScriptZoneLevelSettings> entryList = new List <ScriptZoneLevelSettings>();
foreach (var entry in entriesTable.Values)
{
entryList.Add(new ScriptZoneLevelSettings(entry.Table));
}
return(new ScriptZoneGeneratorSettings(fallback, entryList));
}
public void JsonEmptyArrayVsEmptyObject()
{
object o = new
{
anEmptyObject = new {},
anEmptyArray = new object[] {},
anExplicitEmptyArray = JsonEmptyArray.Create(),
};
string json = JsonTableConverter.ObjectToJson(o);
Table t = JsonTableConverter.ParseString(json, null, true).Table;
Assert.AreEqual(DataType.Table, t.Get("anEmptyObject").Type);
Assert.True(JsonEmptyArray.IsJsonEmptyArray(t.Get("anEmptyArray")));
Assert.True(JsonEmptyArray.IsJsonEmptyArray(t.Get("anExplicitEmptyArray")));
}
public void JsonSerialization()
{
string json = @"{
'aNumber' : 1,
'aString' : '2',
'anObject' : { 'aNumber' : 3, 'aString' : '4' },
'anArray' : [ 5, '6', true, null, { 'aNumber' : 7, 'aString' : '8' } ]
}
" .Replace('\'', '\"');
Table t1 = JsonTableConverter.JsonToTable(json);
string json2 = JsonTableConverter.TableToJson(t1);
Table t = JsonTableConverter.JsonToTable(json2);
AssertTableValues(t);
}
private void Dispatch(string req)
{
try
{
Table request = JsonTableConverter.ParseString(req).Table;
if (request != null && request["type"].ToString() == "request")
{
if (TRACE)
{
Console.Error.WriteLine(string.Format("C {0}: {1}", request["command"], req));
}
var response = new Response(request);
DispatchRequest(request.Get("command").String, request.Get("arguments").Table, response);
SendMessage(response);
}
}
catch
{
}
}
