public void TestRoundTrip()
{
object inObject = true;
object outObject;
string s;
using (Stream output = new MemoryStream())
{
IWriter <object> w = TransitFactory.Writer <object>(TransitFactory.Format.JsonVerbose, output);
w.Write(inObject);
output.Position = 0;
var sr = new StreamReader(output);
s = sr.ReadToEnd();
}
byte[] buffer = Encoding.ASCII.GetBytes(s);
using (Stream input = new MemoryStream(buffer))
{
IReader reader = TransitFactory.Reader(TransitFactory.Format.Json, input);
outObject = reader.Read <object>();
}
Assert.IsTrue(IsEqual(inObject, outObject));
}
public string Write(object obj, TransitFactory.Format format, IDictionary <Type, IWriteHandler> customHandlers)
{
using (Stream output = new MemoryStream())
{
IWriter <object> w = TransitFactory.Writer <object>(format, output, customHandlers);
w.Write(obj);
output.Position = 0;
var sr = new StreamReader(output);
return(sr.ReadToEnd());
}
}
public void TestLink()
{
ILink l1 = TransitFactory.Link("http://google.com/", "search", "name", "link", "prompt");
String str = WriteJson(l1);
ILink l2 = Reader(str).Read <ILink>();
Assert.AreEqual("http://google.com/", l2.Href.AbsoluteUri);
Assert.AreEqual("search", l2.Rel);
Assert.AreEqual("name", l2.Name);
Assert.AreEqual("link", l2.Render);
Assert.AreEqual("prompt", l2.Prompt);
}
public void TestReadUnknown()
{
Assert.AreEqual(TransitFactory.TaggedValue("j", "foo"), Reader("\"~jfoo\"").Read <ITaggedValue>());
IList <object> l = new List <object> {
1L, 2L
};
ITaggedValue expected = TransitFactory.TaggedValue("point", l);
ITaggedValue result = Reader("{\"~#point\":[1,2]}").Read <ITaggedValue>();
Assert.AreEqual(expected.Tag, result.Tag);
CollectionAssert.AreEqual(((IList <object>)expected.Representation).ToArray(), ((IList <object>)result.Representation).ToArray());
}
public void TestWriteUnknown()
{
var l = new List <object>();
l.Add("`jfoo");
Assert.AreEqual("[\"~`jfoo\"]", WriteJsonVerbose(l));
Assert.AreEqual(ScalarVerbose("\"~`jfoo\""), WriteJsonVerbose("`jfoo"));
var l2 = new List <object>();
l2.Add(1L);
l2.Add(2L);
Assert.AreEqual("{\"~#point\":[1,2]}", WriteJsonVerbose(TransitFactory.TaggedValue("point", l2)));
}
public void TestUseISymbolAsDictionaryKey()
{
IDictionary <object, object> d = new Dictionary <object, object>();
d.Add(TransitFactory.Symbol("foo"), 1);
d.Add("foo", 2);
d.Add(TransitFactory.Symbol("bar"), 3);
d.Add("bar", 4);
Assert.AreEqual(1, d[TransitFactory.Symbol("foo")]);
Assert.AreEqual(2, d["foo"]);
Assert.AreEqual(3, d[TransitFactory.Symbol("bar")]);
Assert.AreEqual(4, d["bar"]);
}
public void TestKeywordHashCode()
{
string s = "foo";
IKeyword k1 = TransitFactory.Keyword("foo");
IKeyword k2 = TransitFactory.Keyword("!foo".Substring(1));
IKeyword k3 = TransitFactory.Keyword("bar");
ISymbol symbol = TransitFactory.Symbol("bar");
Assert.AreEqual(k1.GetHashCode(), k2.GetHashCode());
Assert.IsFalse(k3.GetHashCode() == k1.GetHashCode());
Assert.IsFalse(symbol.GetHashCode() == k1.GetHashCode());
Assert.IsFalse(s.GetHashCode() == k1.GetHashCode());
}
public void TestSymbolHashCode()
{
string s = "foo";
ISymbol sym1 = TransitFactory.Symbol("foo");
ISymbol sym2 = TransitFactory.Symbol("!foo".Substring(1));
ISymbol sym3 = TransitFactory.Symbol("bar");
IKeyword keyword = TransitFactory.Keyword("bar");
Assert.AreEqual(sym1.GetHashCode(), sym2.GetHashCode());
Assert.IsFalse(sym3.GetHashCode() == sym1.GetHashCode());
Assert.IsFalse(keyword.GetHashCode() == sym1.GetHashCode());
Assert.IsFalse(s.GetHashCode() == sym1.GetHashCode());
}
public void TestWriteKeyword()
{
Assert.AreEqual(ScalarVerbose("\"~:foo\""), WriteJsonVerbose(TransitFactory.Keyword("foo")));
Assert.AreEqual(Scalar("\"~:foo\""), WriteJson(TransitFactory.Keyword("foo")));
IList l = new IKeyword[]
{
TransitFactory.Keyword("foo"),
TransitFactory.Keyword("foo"),
TransitFactory.Keyword("foo")
};
Assert.AreEqual("[\"~:foo\",\"~:foo\",\"~:foo\"]", WriteJsonVerbose(l));
Assert.AreEqual("[\"~:foo\",\"^0\",\"^0\"]", WriteJson(l));
}
public void TestSymbolEquality()
{
string s = "foo";
ISymbol sym1 = TransitFactory.Symbol("foo");
ISymbol sym2 = TransitFactory.Symbol("!foo".Substring(1));
ISymbol sym3 = TransitFactory.Symbol("bar");
Assert.AreEqual(sym1, sym2);
Assert.AreEqual(sym2, sym1);
Assert.IsFalse(sym1.Equals(sym3));
Assert.IsFalse(sym3.Equals(sym1));
Assert.IsFalse(s.Equals(sym1));
Assert.IsFalse(sym1.Equals(s));
}
public void TestKeywordEquality()
{
string s = "foo";
IKeyword k1 = TransitFactory.Keyword("foo");
IKeyword k2 = TransitFactory.Keyword("!foo".Substring(1));
IKeyword k3 = TransitFactory.Keyword("bar");
Assert.AreEqual(k1, k2);
Assert.AreEqual(k2, k1);
Assert.IsFalse(k1.Equals(k3));
Assert.IsFalse(k3.Equals(k1));
Assert.IsFalse(s.Equals(k1));
Assert.IsFalse(k1.Equals(s));
}
public void TestKeywordComparator()
{
List <IKeyword> l = new List <IKeyword> {
{ TransitFactory.Keyword("bbb") },
{ TransitFactory.Keyword("ccc") },
{ TransitFactory.Keyword("abc") },
{ TransitFactory.Keyword("dab") }
};
l.Sort();
Assert.AreEqual("abc", l[0].ToString());
Assert.AreEqual("bbb", l[1].ToString());
Assert.AreEqual("ccc", l[2].ToString());
Assert.AreEqual("dab", l[3].ToString());
}
public void TestSymbolComparator()
{
List <ISymbol> l = new List <ISymbol> {
{ TransitFactory.Symbol("bbb") },
{ TransitFactory.Symbol("ccc") },
{ TransitFactory.Symbol("abc") },
{ TransitFactory.Symbol("dab") }
};
l.Sort();
Assert.AreEqual("abc", l[0].ToString());
Assert.AreEqual("bbb", l[1].ToString());
Assert.AreEqual("ccc", l[2].ToString());
Assert.AreEqual("dab", l[3].ToString());
}
public override object Representation(object obj)
{
dynamic o = obj;
if (StringableKeys(o))
{
return(Enumerable.ToList(o));
}
else
{
var l = new List <object>();
foreach (var item in o)
{
l.Add(item.Key);
l.Add(item.Value);
}
return(TransitFactory.TaggedValue("array", l));
}
}
public void TestWriteSymbol()
{
Assert.AreEqual(ScalarVerbose("\"~$foo\""), WriteJsonVerbose(TransitFactory.Symbol("foo")));
}
public object FromRepresentation(object representation)
{
return(TransitFactory.Keyword((string)representation));
}
public IReader Reader(string s)
{
Stream input = new MemoryStream(Encoding.Default.GetBytes(s));
return(TransitFactory.Reader(TransitFactory.Format.Json, input));
}
public ITaggedValue FromRepresentation(string tag, object representation)
{
return(TransitFactory.TaggedValue(tag, representation));
}
public override object Representation(object obj)
{
return(TransitFactory.TaggedValue("array", obj));
}
public string Write(object obj, TransitFactory.Format format, IDictionary<Type, IWriteHandler> customHandlers)
{
using (Stream output = new MemoryStream())
{
IWriter<object> w = TransitFactory.Writer<object>(format, output, customHandlers);
w.Write(obj);
output.Position = 0;
var sr = new StreamReader(output);
return sr.ReadToEnd();
}
}