public void Format_StringTokenEscapedChars_ReturnsString()
{
var input = new[]
{
ModelGrammar.TokenPrimitive("\\\b\f\n\r\t\u0123\u4567\u89AB\uCDEF\uabcd\uef4A\"")
};
const string expected = @"""\\\b\f\n\r\t\u0123\u4567\u89AB\uCDEF\uABCD\uEF4A\""""";
var formatter = new JsonWriter.JsonFormatter(new DataWriterSettings());
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public void Format_NumberTokenNegLong_ReturnsNumber()
{
var input = new[]
{
ModelGrammar.TokenPrimitive(-34L)
};
const string expected = "-34";
var formatter = new JsonWriter.JsonFormatter(new DataWriterSettings());
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public void Format_NumberTokenNegNoLeadingDigitDouble_ReturnsNumber()
{
var input = new[]
{
ModelGrammar.TokenPrimitive(-.123456)
};
const string expected = "-0.123456";
var formatter = new JsonWriter.JsonFormatter(new DataWriterSettings());
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public void Format_StringTokenUnescapedSingleQuote_ReturnsString()
{
var input = new[]
{
ModelGrammar.TokenPrimitive("unescaped ' single quote"),
};
const string expected = @"""unescaped ' single quote""";
var formatter = new JsonWriter.JsonFormatter(new DataWriterSettings());
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public void Format_StringTokenEmpty_ReturnsEmptyString()
{
var input = new[]
{
ModelGrammar.TokenPrimitive(String.Empty)
};
const string expected = "\"\"";
var formatter = new JsonWriter.JsonFormatter(new DataWriterSettings());
var actual = formatter.Format(input);
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);
}
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 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 GetTokens_XmlEntityLt_ReturnsSequence()
{
var input = new[]
{
MarkupGrammar.TokenPrimitive("<")
};
var expected = new[]
{
ModelGrammar.TokenPrimitive("<")
};
var converter = new JsonMLReader.JsonMLInTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void TryRead_EasternStandardTimeZone_ReadsAsUtc()
{
var input = Stream <Token <ModelTokenType> > .Create(new[]
{
ModelGrammar.TokenPrimitive("2008-02-29T23:59:59.999-06:00")
});
var expected = new DateTime(2008, 3, 01, 05, 59, 59, 999, DateTimeKind.Utc);
DateTime actual;
Assert.True(new Iso8601DateFilter().TryRead(new DataReaderSettings(), input, out actual));
Assert.Equal(expected.Kind, actual.Kind);
Assert.Equal(expected.Ticks, actual.Ticks);
}
public void TryRead_DateTimeMaxValueUtc_ReadsAsUtc()
{
var input = Stream <Token <ModelTokenType> > .Create(new[]
{
ModelGrammar.TokenPrimitive("9999-12-31T23:59:59.999Z")
});
var expected = new DateTime(9999, 12, 31, 23, 59, 59, 999, DateTimeKind.Utc);
DateTime actual;
Assert.True(new Iso8601DateFilter().TryRead(new DataReaderSettings(), input, out actual));
Assert.Equal(expected.Kind, actual.Kind);
Assert.Equal(expected.Ticks, actual.Ticks);
}
public void TryRead_DateTimeMinValueUtc_ReadsAsUtc()
{
var input = Stream <Token <ModelTokenType> > .Create(new[]
{
ModelGrammar.TokenPrimitive("0001-01-01T00:00:00.000Z")
});
var expected = new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
DateTime actual;
Assert.True(new Iso8601DateFilter().TryRead(new DataReaderSettings(), input, out actual));
Assert.Equal(expected.Kind, actual.Kind);
Assert.Equal(expected.Ticks, actual.Ticks);
}
public void TryRead_FutureEasternTimeZone_ReadsAsUtc()
{
var input = Stream <Token <ModelTokenType> > .Create(new[]
{
ModelGrammar.TokenPrimitive("2099-12-31T23:59:59.999-05:00")
});
var expected = new DateTime(2100, 1, 1, 4, 59, 59, 999, DateTimeKind.Utc);
DateTime actual;
Assert.True(new Iso8601DateFilter().TryRead(new DataReaderSettings(), input, out actual));
Assert.Equal(expected.Kind, actual.Kind);
Assert.Equal(expected.Ticks, actual.Ticks);
}
public void TryRead_EasternDaylightSavingsTimeZone_ReadsAsUtc()
{
var input = Stream <Token <ModelTokenType> > .Create(new[]
{
ModelGrammar.TokenPrimitive("2010-07-05T10:51:17.768-05:00")
});
var expected = new DateTime(2010, 7, 5, 15, 51, 17, 768, DateTimeKind.Utc);
DateTime actual;
Assert.True(new Iso8601DateFilter().TryRead(new DataReaderSettings(), input, out actual));
Assert.Equal(expected.Kind, actual.Kind);
Assert.Equal(expected.Ticks, actual.Ticks);
}
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 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 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_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 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_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_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 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_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 TryRead_DateTimeExplicitTimeZone_ReadsAsUtc()
{
var input = Stream <Token <ModelTokenType> > .Create(new[]
{
ModelGrammar.TokenPrimitive(@"\/Date(1262427133000+0100)\/")
});
// currently this just ignores the WCF time zone info
var expected = new DateTime(2010, 1, 2, 10, 12, 13, 0, 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_ObjectOneProperty_ReturnsSimpleObject()
{
var input = new[]
{
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty("key"),
ModelGrammar.TokenPrimitive("value"),
ModelGrammar.TokenObjectEnd
};
const string expected = @"{""key"":""value""}";
var formatter = new JsonWriter.JsonFormatter(new DataWriterSettings());
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public void GetTokens_NestedDefaultNamespaces_ReturnsSequence()
{
var input = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("outer", String.Empty, "http://example.org/outer")),
MarkupGrammar.TokenElementBegin(new DataName("middle-1", String.Empty, "http://example.org/inner")),
MarkupGrammar.TokenElementBegin(new DataName("inner", String.Empty, "http://example.org/inner")),
MarkupGrammar.TokenPrimitive("this should be inner"),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementBegin(new DataName("middle-2", String.Empty, "http://example.org/outer")),
MarkupGrammar.TokenPrimitive("this should be outer"),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd
};
var expected = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive("outer"),
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty("xmlns"),
ModelGrammar.TokenPrimitive("http://example.org/outer"),
ModelGrammar.TokenObjectEnd,
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive("middle-1"),
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty("xmlns"),
ModelGrammar.TokenPrimitive("http://example.org/inner"),
ModelGrammar.TokenObjectEnd,
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive("inner"),
ModelGrammar.TokenPrimitive("this should be inner"),
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive("middle-2"),
ModelGrammar.TokenPrimitive("this should be outer"),
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenArrayEnd
};
var converter = new JsonMLReader.JsonMLInTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void Format_ObjectOneNamespacedProperty_CorrectlyIgnoresNamespace()
{
var input = new[]
{
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty(new DataName("key", null, "http://json.org")),
ModelGrammar.TokenPrimitive("value"),
ModelGrammar.TokenObjectEnd
};
const string expected = @"{""key"":""value""}";
var formatter = new JsonWriter.JsonFormatter(new DataWriterSettings());
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public void GetTokens_ArrayNested_ReturnsNestedArrayTokens()
{
var input = new object[]
{
false,
true,
null,
new []
{
'a',
'b',
'c'
},
new []
{
1,
2,
3
}
};
var expected = new[]
{
ModelGrammar.TokenArrayBegin("array"),
ModelGrammar.TokenFalse,
ModelGrammar.TokenTrue,
ModelGrammar.TokenNull,
ModelGrammar.TokenArrayBegin("array"),
ModelGrammar.TokenPrimitive('a'),
ModelGrammar.TokenPrimitive('b'),
ModelGrammar.TokenPrimitive('c'),
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenArrayBegin("array"),
ModelGrammar.TokenPrimitive(1),
ModelGrammar.TokenPrimitive(2),
ModelGrammar.TokenPrimitive(3),
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenArrayEnd
};
var walker = new ModelWalker(new DataWriterSettings());
var actual = walker.GetTokens(input).ToArray();
Assert.Equal(expected, actual);
}
public void TryWrite_DateTimeMaxValue_DirectlyWritesAsUtc()
{
var input = DateTime.MaxValue;
var expected = new[]
{
ModelGrammar.TokenPrimitive(@"\/Date(253402300800000)\/")
};
IEnumerable <Token <ModelTokenType> > actual;
Assert.True(new MSAjaxDateFilter().TryWrite(new DataWriterSettings(), input, out actual));
Assert.NotNull(actual);
Assert.Equal(expected.Count(), actual.Count());
Assert.Equal(expected[0].TokenType, actual.First().TokenType);
Assert.Equal(expected[0].Value, actual.First().Value);
}
