public void Maybe_Serializes_Objects()
{
var converter = new MaybeConverter();
var expectedJust = "{\"F\":123}";
var just = new Maybe <Foo>(new Foo {
F = 123
});
var actualJust = JsonConvert.SerializeObject(just, Formatting.None, converter);
var expectedNone = "null";
var none = new Maybe <Foo>();
var actualNone = JsonConvert.SerializeObject(none, Formatting.None, converter);
var expectedInt = "789";
var justInt = new Maybe <int>(789);
var actualInt = JsonConvert.SerializeObject(justInt, Formatting.None, converter);
var actualReadFoo = JsonConvert.DeserializeObject <Maybe <Foo> >("{\"F\":999}", converter);
var actualReadNone = JsonConvert.DeserializeObject <Maybe <Foo> >("null", converter);
var actualReadInt = JsonConvert.DeserializeObject <Maybe <int> >("456", converter);
Assert.Equal(expectedJust, actualJust);
Assert.Equal(expectedNone, actualNone);
Assert.Equal(expectedInt, actualInt);
Assert.Equal(-1, actualReadNone.Map(x => x.F).Extract(-1));
Assert.Equal(999, actualReadFoo.Map(x => x.F).Extract(-1));
Assert.Equal(456, actualReadInt.Extract(-1));
}
public void TestReadJsonWithNull()
{
var maybeConverter = new MaybeConverter();
var obj = JsonConvert.DeserializeObject("null", typeof(Maybe <int>), maybeConverter);
Assert.IsTrue(obj is Maybe <int>);
Assert.IsFalse(((Maybe <int>)obj).HasValue);
}
public void TestWriteJsonWithValue()
{
var maybeConverter = new MaybeConverter();
Assert.AreEqual("3", JsonConvert.SerializeObject(Maybe.FromValue(3), maybeConverter));
Assert.AreEqual("true", JsonConvert.SerializeObject(Maybe.FromValue(true), maybeConverter));
Assert.AreEqual("\"Test\"", JsonConvert.SerializeObject(Maybe.FromValue("Test"), maybeConverter));
}
public void TestWriteJsonWithComplexValue()
{
var maybeConverter = new MaybeConverter();
Maybe <List <Maybe <int> > > complex = new List <Maybe <int> >();
complex.Value.Add(Maybe <int> .None);
Assert.AreEqual("[]", JsonConvert.SerializeObject(complex, maybeConverter));
complex.Value.AddRange(new[] { Maybe.FromValue(232), 9 });
Assert.AreEqual("[232,9]", JsonConvert.SerializeObject(complex, maybeConverter));
}
public void TestReadJsonWithConversionValue()
{
var maybeConverter = new MaybeConverter();
var objGuid = JsonConvert.DeserializeObject("\"dc95aa3e-c209-4225-becb-3f28eca1ea56\"", typeof(Maybe <Guid>), maybeConverter);
Assert.IsTrue(objGuid is Maybe <Guid>);
var mguid = (Maybe <Guid>)objGuid;
Assert.IsTrue(mguid.HasValue);
}
public void TestCanConvert()
{
MaybeConverter mc = new MaybeConverter();
Assert.IsFalse(mc.CanConvert(typeof(int)));
Assert.IsFalse(mc.CanConvert(typeof(bool)));
Assert.IsFalse(mc.CanConvert(typeof(string)));
Assert.IsFalse(mc.CanConvert(typeof(int?)));
Assert.IsTrue(mc.CanConvert(typeof(Maybe <int>)));
Assert.IsTrue(mc.CanConvert(typeof(Maybe <string>)));
Assert.IsTrue(mc.CanConvert(typeof(Maybe <int?>)));
}
public void TestReadJsonWithComplexValue()
{
var maybeConverter = new MaybeConverter();
var objBool = JsonConvert.DeserializeObject("[true,false,false,true,null]", typeof(Maybe <List <Maybe <bool> > >), maybeConverter);
Assert.IsTrue(objBool is Maybe <List <Maybe <bool> > >);
var mlist = (Maybe <List <Maybe <bool> > >)objBool;
Assert.IsTrue(mlist.HasValue);
Assert.AreEqual(5, mlist.Value.Count);
Assert.IsTrue(mlist.Value.Contains(Maybe <bool> .None));
}
public void TestReadJsonWithValue()
{
var maybeConverter = new MaybeConverter();
var objStr = JsonConvert.DeserializeObject("\"MaybeHero\"", typeof(Maybe <string>), maybeConverter);
Assert.IsTrue(objStr is Maybe <string>);
Assert.IsTrue(((Maybe <string>)objStr).HasValue);
Assert.AreEqual("MaybeHero", ((Maybe <string>)objStr).Value);
var objInt = JsonConvert.DeserializeObject("432324328", typeof(Maybe <int>), maybeConverter);
Assert.IsTrue(objInt is Maybe <int>);
Assert.IsTrue(((Maybe <int>)objInt).HasValue);
Assert.AreEqual(432324328, ((Maybe <int>)objInt).Value);
}
public void TestWriteJsonNoValue()
{
var maybeConverter = new MaybeConverter();
Assert.AreEqual("", JsonConvert.SerializeObject(Maybe <string> .None, maybeConverter));
}
