public void TestSkippingProperty()
{
NetJSON.GenerateAssembly = true;
var ss = "{\"aaaaaaaaaa\":\"52\",\"aaaaaURL\":\"x\"}";
var yy = NetJSON.Deserialize <Foo>(ss);
}
public void StringSkippingCauseInfiniteLoop2()
{
NetJSON.UseStringOptimization = true;
string jsonData = "{ \"token\":\"sFdDNKjLPZJSm0+gvsD1PokoJd3YzbbsClttbWLWz50=\",\"product\":\"productblabla\",\"status\":\"SUCCESS\",\"error\":\"\" }";
var data = NetJSON.Deserialize <BaseApiResponse>(jsonData);
}
public void TestDictionaryWithColon()
{
var dict = new Dictionary <string, string>();
dict["Test:Key"] = "Value";
var json = NetJSON.Serialize(dict);
var ddict = NetJSON.Deserialize <Dictionary <string, string> >(json);
}
public void TestSerializeDateWithMillisecondDefaultFormatLocal()
{
NetJSON.DateFormat = NetJSONDateFormat.Default;
NetJSON.TimeZoneFormat = NetJSONTimeZoneFormat.Local;
var date = new DateTime(2010, 12, 05, 1, 1, 30, 100);
var djson = NetJSON.Serialize(date);
var ddate = NetJSON.Deserialize <DateTime>(djson);
}
public void SerializeObjectWithQuotes()
{
var obj = new APIQuote {
createDate = DateTime.Now, value = "Hello world"
};
var json = NetJSON.Serialize(obj);
var obj2 = NetJSON.Deserialize <APIQuote>(json);
}
public void TestSerializeTuple()
{
NetJSON.GenerateAssembly = true;
var tuple = new Tuple <int, string>(100, "Hello World");
var json = NetJSON.Serialize(tuple);
var ttuple = NetJSON.Deserialize <Tuple <int, string> >(json);
}
public void CanSerializeSimpleObject()
{
var simple = new SimpleObject {
MyInt = 1000, MyString = "Hello World"
};
var json = NetJSON.Serialize(simple);
var simple2 = NetJSON.Deserialize <SimpleObject>(json);
}
public void TestSerializeDateNowUtcWithISOFormatUTC()
{
NetJSON.DateFormat = NetJSONDateFormat.ISO;
NetJSON.TimeZoneFormat = NetJSONTimeZoneFormat.Utc;
var date = DateTime.UtcNow;
var djson = NetJSON.Serialize(date);
var ddate = NetJSON.Deserialize <DateTime>(djson);
Assert.IsTrue(date == ddate);
}
public void TestSerializeDateWithISOFormatUTC()
{
NetJSON.DateFormat = NetJSONDateFormat.ISO;
NetJSON.TimeZoneFormat = NetJSONTimeZoneFormat.Utc;
var date = new DateTime(2010, 12, 05, 1, 1, 30, 99);
var djson = NetJSON.Serialize(date);
var ddate = NetJSON.Deserialize <DateTime>(djson);
Assert.IsTrue(date == ddate);
}
public void TestSerializeDateWithISOFormatLocal()
{
NetJSON.DateFormat = NetJSONDateFormat.ISO;
NetJSON.TimeZoneFormat = NetJSONTimeZoneFormat.Local;
var date = DateTime.Now;
var djson = NetJSON.Serialize(date);
var ddate = NetJSON.Deserialize <DateTime>(djson);
Assert.IsTrue(date == ddate);
}
public void TestSerializeDateWithMillisecondDefaultFormatUnSpecified()
{
NetJSON.DateFormat = NetJSONDateFormat.Default;
NetJSON.TimeZoneFormat = NetJSONTimeZoneFormat.Unspecified;
var date = DateTime.Now;
var djson = NetJSON.Serialize(date);
var ddate = NetJSON.Deserialize <DateTime>(djson);
Assert.IsTrue(date == ddate);
}
public void TestSerializeDateWithMillisecondDefaultFormatLocal()
{
NetJSON.DateFormat = NetJSONDateFormat.Default;
NetJSON.TimeZoneFormat = NetJSONTimeZoneFormat.Local;
var date = DateTime.UtcNow;
var djson = NetJSON.Serialize(date);
var ddate = NetJSON.Deserialize <DateTime>(djson);
Assert.IsTrue(date == ddate);
}
public void CanSerializeTestData()
{
var data = new TestClass {
ID = 1000, Name = "This is a test"
};
var json = NetJSON.Serialize(data);
var data2 = NetJSON.Deserialize <TestClass>(json);
Assert.Equal(data.ID, data2.ID);
}
public void O2_Get_NetJsonString()
{
foreach (var item in this.ListForReading)
{
string key = $"o2_netjson:{item.GetFullKey()}";
string result = this.Cache.GetJson <string>(key);
result = System.Text.RegularExpressions.Regex.Unescape(result);
IDictionary <string, IEnumerable <string> > reasons = NetJSON.Deserialize <IDictionary <string, IEnumerable <string> > >(result);
}
}
public void TestStructWithFields()
{
var data = new StructWithFields {
x = 10, y = 2
};
var json = NetJSON.Serialize(data);
var data2 = NetJSON.Deserialize <StructWithFields>(json);
Assert.AreEqual(data.x, data.x);
Assert.AreEqual(data.y, data.y);
}
public void CanDeserialiseNullableGuid()
{
var itm = new Guid("10b5a72b-815f-4e64-90bf-cb250840e989");
var testObj = new NullableTestType <Guid>(itm);
var serialised = NetJSON.Serialize(testObj);
var deserialised = NetJSON.Deserialize <NullableTestType <Guid> >(serialised);
Assert.IsNotNull(deserialised);
Assert.IsNotNull(deserialised.TestItem);
Assert.AreEqual(testObj.TestItem.Value, itm);
}
public void TestSerializeComplexTuple()
{
var tuple = new Tuple <int, DateTime, string,
Tuple <double, List <string> > >(1, DateTime.Now, "xisbound",
new Tuple <double, List <string> >(45.45, new List <string> {
"hi", "man"
}));
var json = NetJSON.Serialize(tuple);
var ttuple = NetJSON.Deserialize <Tuple <int, DateTime, string, Tuple <double, List <string> > > >(json);
}
public void CanDeserialiseNullableDateTime()
{
var itm = new DateTime(2015, 12, 15);
var testObj = new NullableTestType <DateTime>(itm);
var serialised = NetJSON.Serialize(testObj);
var deserialised = NetJSON.Deserialize <NullableTestType <DateTime> >(serialised);
Assert.IsNotNull(deserialised);
Assert.IsNotNull(deserialised.TestItem);
Assert.AreEqual(testObj.TestItem.Value, itm);
}
static void Main(string[] args)
{
Console.WriteLine("Define invalid JSON");
//var json = "{\"Value\":\"\",\"Regex\":false}"; //good JSON
var json = "{\"Value:\"\",\"Regex\":false}"; //bad JSON
Console.WriteLine("Run Deserialize");
var simple2 = NetJSON.Deserialize <Dummy>(json);
Console.WriteLine("Done");
}
public void TestNetJSONProperty()
{
NetJSON.IncludeFields = true;
var sample = new SampleSubstitionClass {
ID = 100, Name = "Test Property", Number = 504
};
var json = NetJSON.Serialize(sample);
var sData = NetJSON.Deserialize <SampleSubstitionClass>(json);
}
public void CanDeserialiseNullableTimespan()
{
var itm = new TimeSpan(1500);
var testObj = new NullableTestType <TimeSpan>(itm);
var serialised = NetJSON.Serialize(testObj);
var deserialised = NetJSON.Deserialize <NullableTestType <TimeSpan> >(serialised);
Assert.IsNotNull(deserialised);
Assert.IsNotNull(deserialised.TestItem);
Assert.AreEqual(testObj.TestItem.Value, itm);
}
public void SerializeDateTimeOffSet()
{
var settings = new NetJSONSettings {
TimeZoneFormat = NetJSONTimeZoneFormat.Local, DateFormat = NetJSONDateFormat.ISO
};
var dateTimeOffset = new DateTimeOffset(DateTime.Now);
var json = NetJSON.Serialize(dateTimeOffset, settings);
var dateTimeOffset2 = NetJSON.Deserialize <DateTimeOffset>(json, settings);
Assert.AreEqual(dateTimeOffset, dateTimeOffset2);
}
public void TestDateTimeFormat()
{
var json = "{\"DateTimeValue\":\"\\/Date(1447003080000+0200)\\/\"}";
var json2 = "{\"DateTimeValue\":\"2015-11-08T19:18:00+02:00\"}";
NetJSON.DateFormat = NetJSONDateFormat.Default;
var obj = NetJSON.Deserialize <TestDateTimeFormatting>(json);
var sobj = NetJSON.Serialize(obj);
NetJSON.DateFormat = NetJSONDateFormat.JsonNetISO;
var obj2 = NetJSON.Deserialize <TestDateTimeFormatting>(json2);
var sobj2 = NetJSON.Serialize(obj2);
}
public void TestSerializeTypeClass()
{
var type = typeof(String);
var value = NetJSON.Serialize(type);
var typeType = NetJSON.Deserialize <Type>(value);
var typeHolder = new TypeHolder {
Type = typeof(int)
};
var valueHolder = NetJSON.Serialize(typeHolder);
var typeHolderType = NetJSON.Deserialize <TypeHolder>(valueHolder);
}
public void CanSerializeSimpleObject()
{
NetJSON.GenerateAssembly = true;
NetJSON.DateFormat = NetJSONDateFormat.ISO;
var simple = new SimpleObject {
MyInt = 1000, MyString = "Hello World", Timestamp = DateTime.UtcNow
};
var json = NetJSON.Serialize(simple);
var simple2 = NetJSON.Deserialize <SimpleObject>(json);
Assert.AreEqual <int>(simple.MyInt, simple2.MyInt);
Assert.AreEqual <string>(simple.MyString, simple2.MyString);
Assert.AreEqual <DateTime>(simple.Timestamp, simple2.Timestamp);
}
public void SerializeDateTimeOffSetWithDifferentOffset()
{
var settings = new NetJSONSettings {
TimeZoneFormat = NetJSONTimeZoneFormat.Local, DateFormat = NetJSONDateFormat.ISO
};
var now = DateTime.Now;
var dateTimeOffset = new DateTimeOffset(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second, new TimeSpan(2, 0, 0));
var json = NetJSON.Serialize(dateTimeOffset, settings);
var dateTimeOffset2 = NetJSON.Deserialize <DateTimeOffset>(json, settings);
Assert.AreEqual(dateTimeOffset, dateTimeOffset2);
}
public void TestSerializeException()
{
NetJSON.UseStringOptimization = true;
var exception = new ExceptionInfoEx {
Data = new Dictionary <string, string> {
{ "Test1", "Hello" }
},
ExceptionType = typeof(InvalidCastException),
HelpLink = "HelloWorld",
InnerException = new ExceptionInfoEx {
HelpLink = "Inner"
},
Message = "Nothing here", Source = "Not found", StackTrace = "I am all here"
};
var json = NetJSON.Serialize(exception);
var exceptionResult = NetJSON.Deserialize <ExceptionInfoEx>(json);
}
public void TestSerializeDictionaryWithComplexDictionaryString()
{
NetJSON.IncludeFields = true;
Dictionary <string, string> sub1 = new Dictionary <string, string> {
{ "k1", "v1\"well" }, { "k2", "v2\"alsogood" }
};
var sub1Json = NetJSON.Serialize(sub1);
Dictionary <string, string> main = new Dictionary <string, string> {
{ "MK1", sub1Json },
{ "MK2", sub1Json }
};
//At this moment we got in dictionary 2 keys with string values. Every string value is complex and actually is the other serialized Dictionary
string final = NetJSON.Serialize(main);
//Trying to get main dictionary back and it fails
var l1 = NetJSON.Deserialize <Dictionary <string, string> >(final);
Assert.IsTrue(l1.Count == 2);
}
public void TestSerializePrimitveTypes()
{
var x = 10;
var s = "Hello World";
var d = DateTime.Now;
var xjson = NetJSON.Serialize(x);
var xx = NetJSON.Deserialize <int>(xjson);
var sjson = NetJSON.Serialize(s);
var ss = NetJSON.Deserialize <string>(sjson);
var djson = NetJSON.Serialize(d);
var dd = NetJSON.Deserialize <DateTime>(djson);
var ejson = NetJSON.Serialize(SampleEnum.TestEnum1);
var ee = NetJSON.Deserialize <SampleEnum>(ejson);
var bjson = NetJSON.Serialize(true);
var bb = NetJSON.Deserialize <bool>(bjson);
}
public T Deserialize(string s)
{
T merchant = NetJSON.Deserialize <T>(s);
return(merchant);
}
