public void Analyze_ObjectEmpty_ReturnsEmptyObject()
{
var input = new[]
{
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenObjectEnd
};
var expected = new Dictionary <string, object>();
var analyzer = new ModelAnalyzer(new DataReaderSettings());
var actual = analyzer.Analyze(input).Cast <IDictionary <string, object> >().Single();
Assert.Equal(expected, actual, false);
}
public void Analyze_ArrayEmpty_ReturnsEmptyArray()
{
var input = new []
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenArrayEnd
};
var expected = new object[0];
var analyzer = new ModelAnalyzer(new DataReaderSettings());
var actual = analyzer.Analyze(input).Cast <object[]>().Single();
Assert.Equal(expected, actual);
}
public void Analyze_NullInput_ThrowsArgumentNullException()
{
var input = (IEnumerable <Token <ModelTokenType> >)null;
var analyzer = new ModelAnalyzer(new DataReaderSettings());
ArgumentNullException ex = Assert.Throws <ArgumentNullException>(
delegate
{
var actual = analyzer.Analyze <object>(input).Single();
});
// verify exception is coming from expected param
Assert.Equal("tokens", ex.ParamName);
}
public void Format_ArrayEmpty_ReturnsEmptyArray()
{
var input = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenArrayEnd
};
const string expected = "[]";
var formatter = new JsonWriter.JsonFormatter(new DataWriterSettings());
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public void GetTokens_DifferentPrefixSameNamespace_ReturnsSequence()
{
const string input = @"<foo xmlns=""http://example.org"" xmlns:blah=""http://example.org"" blah:key=""value"" />";
var expected = new[]
{
MarkupGrammar.TokenElementVoid(new DataName("foo", String.Empty, "http://example.org")),
MarkupGrammar.TokenAttribute(new DataName("key", "blah", "http://example.org")),
MarkupGrammar.TokenPrimitive("value")
};
var tokenizer = new XmlReader.XmlTokenizer();
var actual = tokenizer.GetTokens(input).ToArray();
Assert.Equal(expected, actual);
}
public void Format_StringTokenSurrogatePair_ReturnsString()
{
var input = new[]
{
// 'BLUE HEART' (U+1F499)
ModelGrammar.TokenPrimitive("\uD83D\uDC99")
};
const string expected = @"""\u1F499""";
var formatter = new JsonWriter.JsonFormatter(new DataWriterSettings());
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
//[Fact(Skip="System.Xml.XmlSerializer array output is worthless.")]
public void Write_CompareArrayOutputToXmlSerializer_Serializes()
{
var input = new object[]
{
false,
new DateTime(2008, 2, 29, 23, 59, 59, 999, DateTimeKind.Utc),
42,
"Ordinary string"
};
var expected = SystemXmlWriter(input, CreateSettings(false));
var actual = new XmlWriter(new DataWriterSettings(new XmlResolverStrategy())).Write(input);
Assert.Equal(expected.ToString(), actual);
}
public void Read_DeserializesStreamOfObject()
{
using (var stream = WebRequest.Create("https://api.twitter.com/1/statuses/user_timeline.json?screen_name=jsonfx&count=2")
.GetResponse()
.GetResponseStream())
{
var input = new StreamReader(stream);
var reader = new JsonReader(new DataReaderSettings());
dynamic actual = reader.Read(input);
Assert.Equal(2, actual.Length);
}
}
public void Read_OnlyDefaults_DeserializesIso8601DateTimeFormat()
{
var input = @"[ ""Normal string before"", ""2008-02-29T23:59:59.999Z"", ""2010-07-05T10:51:17.768"", ""Normal string after""]";
var expected = new object[]
{
"Normal string before",
new DateTime(2008, 2, 29, 23, 59, 59, 999, DateTimeKind.Utc),
new DateTime(2010, 7, 5, 10, 51, 17, 768, DateTimeKind.Unspecified),
"Normal string after"
};
var actual = new JsonReader().Read(input);
Assert.Equal(expected, actual);
}
public void Format_NullInput_ThrowsArgumentNullException()
{
var input = (IEnumerable <Token <ModelTokenType> >)null;
var transformer = new HtmlOutTransformer();
ArgumentNullException ex = Assert.Throws <ArgumentNullException>(
delegate
{
var actual = transformer.Transform(input).ToArray();
});
// verify exception is coming from expected param
Assert.Equal("input", ex.ParamName);
}
public void Read_TimeSpans_DeserializesCorrectly()
{
var input = @"[ ""-9223372036854775808"", 0, 316223999990000, ""9223372036854775807""]";
var expected = new TimeSpan[]
{
TimeSpan.MinValue,
new TimeSpan(),
new TimeSpan(365, 23, 59, 59, 999),
TimeSpan.MaxValue
};
var actual = new JsonReader().Read <TimeSpan[]>(input);
Assert.Equal(expected, actual);
}
public void Format_NullInput_ThrowsArgumentNullException()
{
var input = (IEnumerable <Token <ModelTokenType> >)null;
var formatter = new JsonWriter.JsonFormatter(new DataWriterSettings());
ArgumentNullException ex = Assert.Throws <ArgumentNullException>(
delegate
{
var actual = formatter.Format(input);
});
// verify exception is coming from expected param
Assert.Equal("tokens", ex.ParamName);
}
public void Format_ObjectNested_RendersNestedObject()
{
// input from pass3.json in test suite at http://www.json.org/JSON_checker/
var input = new[]
{
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty("JSON Test Pattern pass3"),
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty("The outermost value"),
ModelGrammar.TokenPrimitive("must be an object or array."),
ModelGrammar.TokenProperty("In this test"),
ModelGrammar.TokenPrimitive("It is an object."),
ModelGrammar.TokenObjectEnd,
ModelGrammar.TokenObjectEnd
};
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("div")),
MarkupGrammar.TokenElementBegin(new DataName("dl")),
MarkupGrammar.TokenElementBegin(new DataName("dt")),
MarkupGrammar.TokenPrimitive(new DataName("JSON Test Pattern pass3")),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementBegin(new DataName("dd")),
MarkupGrammar.TokenElementBegin(new DataName("dl")),
MarkupGrammar.TokenElementBegin(new DataName("dt")),
MarkupGrammar.TokenPrimitive(new DataName("The outermost value")),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementBegin(new DataName("dd")),
MarkupGrammar.TokenPrimitive("must be an object or array."),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementBegin(new DataName("dt")),
MarkupGrammar.TokenPrimitive(new DataName("In this test")),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementBegin(new DataName("dd")),
MarkupGrammar.TokenPrimitive("It is an object."),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd
};
var transformer = new HtmlOutTransformer();
var actual = transformer.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void TryRead_DateTimeMaxValueUtc_ReadsAsDateTimeMaxValue()
{
var input = Stream <Token <ModelTokenType> > .Create(new[]
{
ModelGrammar.TokenPrimitive(@"\/Date(253402300800000)\/")
});
var expected = DateTime.MaxValue;
DateTime actual;
Assert.True(new MSAjaxDateFilter().TryRead(new DataReaderSettings(), input, out actual));
Assert.Equal(expected.Kind, actual.Kind);
Assert.Equal(expected.Ticks, actual.Ticks);
}
public void Format_StringTokenSimple_ReturnsString()
{
// input from fail1.json in test suite at http://www.json.org/JSON_checker/
var input = new[]
{
ModelGrammar.TokenPrimitive("A JSON payload should be an object or array, not a string.")
};
const string expected = @"""A JSON payload should be an object or array, not a string.""";
var formatter = new JsonWriter.JsonFormatter(new DataWriterSettings());
var actual = formatter.Format(input);
// this is not allowed according to strict JSON, but we're following Postel's Law
Assert.Equal(expected, actual);
}
public void Format_XmlEntityHex_ReturnsMarkup()
{
var input = new[]
{
MarkupGrammar.TokenPrimitive("\uABCD")
};
const string expected = "\uABCD";
var formatter = new HtmlFormatter(new DataWriterSettings())
{
EncodeNonAscii = false
};
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public void GetTokens_MixedEntities_ReturnsSequence()
{
var input = new[]
{
ModelGrammar.TokenPrimitive(@"there should <b>e decoded chars & inside this text")
};
var expected = new[]
{
MarkupGrammar.TokenPrimitive(@"there should <b>e decoded chars & inside this text")
};
var converter = new JsonMLWriter.JsonMLOutTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_AspNetPageDeclaration_ReturnsUnparsed()
{
var input = new[]
{
ModelGrammar.TokenPrimitive(new UnparsedBlock("%@", "%", @" Page Language=""C#"" AutoEventWireup=""true"" CodeBehind=""Default.aspx.cs"" Inherits=""Foo._Default"" "))
};
var expected = new[]
{
MarkupGrammar.TokenUnparsed("%@", "%", @" Page Language=""C#"" AutoEventWireup=""true"" CodeBehind=""Default.aspx.cs"" Inherits=""Foo._Default"" ")
};
var converter = new JsonMLWriter.JsonMLOutTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_XmlComment_ReturnsUnparsed()
{
var input = new[]
{
ModelGrammar.TokenPrimitive(new UnparsedBlock("!--", "--", @" a quick note "))
};
var expected = new[]
{
MarkupGrammar.TokenUnparsed("!--", "--", @" a quick note ")
};
var converter = new JsonMLWriter.JsonMLOutTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void TryRead_StandardTimeZone_ReadsAsUtc()
{
var input = Stream <Token <ModelTokenType> > .Create(new[]
{
ModelGrammar.TokenPrimitive(@"/Date(1204329599999)/")
});
var expected = new DateTime(2008, 2, 29, 23, 59, 59, 999, DateTimeKind.Utc);
DateTime actual;
Assert.True(new MSAjaxDateFilter().TryRead(new DataReaderSettings(), input, out actual));
Assert.Equal(expected.Kind, actual.Kind);
Assert.Equal(expected.Ticks, actual.Ticks);
}
public void Format_HtmlEntityEuroEncodeNonAscii_ReturnsMarkup()
{
var input = new[]
{
MarkupGrammar.TokenPrimitive("€")
};
const string expected = @"€";
var formatter = new HtmlFormatter(new DataWriterSettings())
{
EncodeNonAscii = true
};
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public void TryRead_DaylightSavingsTimeZone_ReadsAsUtc()
{
var input = Stream <Token <ModelTokenType> > .Create(new[]
{
ModelGrammar.TokenPrimitive(@"\/Date(1278327077768)\/")
});
var expected = new DateTime(2010, 7, 5, 10, 51, 17, 768, DateTimeKind.Utc);
DateTime actual;
Assert.True(new MSAjaxDateFilter().TryRead(new DataReaderSettings(), input, out actual));
Assert.Equal(expected.Kind, actual.Kind);
Assert.Equal(expected.Ticks, actual.Ticks);
}
public void TryRead_FutureTimeZone_ReadsAsUtc()
{
var input = Stream <Token <ModelTokenType> > .Create(new[]
{
ModelGrammar.TokenPrimitive(@"\/Date(4102444799999)\/")
});
var expected = new DateTime(2099, 12, 31, 23, 59, 59, 999, DateTimeKind.Utc);
DateTime actual;
Assert.True(new MSAjaxDateFilter().TryRead(new DataReaderSettings(), input, out actual));
Assert.Equal(expected.Kind, actual.Kind);
Assert.Equal(expected.Ticks, actual.Ticks);
}
public void GetTokens_AttributeWhitespaceQuotDelims_ReturnsSequence()
{
const string input = @"<root white = "" extra whitespace around quote delims "" ></root>";
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("root")),
MarkupGrammar.TokenAttribute(new DataName("white")),
MarkupGrammar.TokenPrimitive(" extra whitespace around quote delims "),
MarkupGrammar.TokenElementEnd
};
var tokenizer = new XmlReader.XmlTokenizer();
var actual = tokenizer.GetTokens(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_EntityWithTrailingText_ReturnsSequence()
{
var input = new[]
{
ModelGrammar.TokenPrimitive("&trailing")
};
var expected = new[]
{
MarkupGrammar.TokenPrimitive("&trailing")
};
var converter = new JsonMLWriter.JsonMLOutTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_SingleAttributeWhitespace_ReturnsSequence()
{
const string input = @"<root whitespace="" this contains whitespace ""></root>";
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("root")),
MarkupGrammar.TokenAttribute(new DataName("whitespace")),
MarkupGrammar.TokenPrimitive(" this contains whitespace "),
MarkupGrammar.TokenElementEnd
};
var tokenizer = new XmlReader.XmlTokenizer();
var actual = tokenizer.GetTokens(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_XmlDeclaration_ReturnsUnparsed()
{
var input = new[]
{
ModelGrammar.TokenPrimitive(new UnparsedBlock("?", "?", @"xml version=""1.0"""))
};
var expected = new[]
{
MarkupGrammar.TokenUnparsed("?", "?", @"xml version=""1.0""")
};
var converter = new JsonMLWriter.JsonMLOutTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void Format_SingleAttributeWhitespace_ReturnsMarkup()
{
var input = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("root")),
MarkupGrammar.TokenAttribute(new DataName("whitespace")),
MarkupGrammar.TokenPrimitive(" this contains whitespace "),
MarkupGrammar.TokenElementEnd
};
const string expected = @"<root whitespace="" this contains whitespace ""></root>";
var formatter = new HtmlFormatter(new DataWriterSettings());
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public void GetTokens_TextValue_ReturnsTextValue()
{
var input = new[]
{
ModelGrammar.TokenPrimitive(@"value>""0"" && value<""10"" ?""valid"":""error""")
};
var expected = new[]
{
MarkupGrammar.TokenPrimitive(@"value>""0"" && value<""10"" ?""valid"":""error""")
};
var converter = new JsonMLWriter.JsonMLOutTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_SingleAttributeEmptyValue_ReturnsSequence()
{
const string input = @"<root emptyValue=""""></root>";
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("root")),
MarkupGrammar.TokenAttribute(new DataName("emptyValue")),
MarkupGrammar.TokenPrimitive(String.Empty),
MarkupGrammar.TokenElementEnd
};
var tokenizer = new XmlReader.XmlTokenizer();
var actual = tokenizer.GetTokens(input).ToArray();
Assert.Equal(expected, actual);
}