public void Format_ArrayOneItem_ReturnsExpectedArray()
{
var input = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("array")),
MarkupGrammar.TokenElementVoid(new DataName("item")),
MarkupGrammar.TokenElementEnd
};
var expected = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenNull,
ModelGrammar.TokenArrayEnd
};
var transformer = new XmlReader.XmlInTransformer(new DataReaderSettings());
var actual = transformer.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void Read_ObjectExtraValueAfterClose_ThrowsDeserializationException()
{
// input from fail10.json in test suite at http://www.json.org/JSON_checker/
var input = @"{""Extra value after close"": true} ""misplaced quoted value""";
var reader = new JsonReader(new DataReaderSettings {
AllowTrailingContent = false
});
DeserializationException ex = Assert.Throws <DeserializationException>(
delegate
{
var actual = reader.Read(input);
});
// verify exception is coming from expected position
// note the reader doesn't see the 2nd object until it is read
// so the index is after the trailing value
Assert.Equal(57L, ex.Index);
}
public void Analyze_ObjectOneProperty_ReturnsSimpleObject()
{
var input = new[]
{
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty("key"),
ModelGrammar.TokenPrimitive("value"),
ModelGrammar.TokenObjectEnd
};
var expected = new Dictionary <string, object>
{
{ "key", "value" }
};
var analyzer = new ModelAnalyzer(new DataReaderSettings());
var actual = analyzer.Analyze(input).Cast <IDictionary <string, object> >().Single();
Assert.Equal(expected, actual, false);
}
public void Analyze_ArrayUnclosed_ThrowsAnalyzerException()
{
// input from fail2.json in test suite at http://www.json.org/JSON_checker/
var input = new []
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive("Unclosed array")
};
var analyzer = new ModelAnalyzer(new DataReaderSettings());
TokenException <ModelTokenType> ex = Assert.Throws <TokenException <ModelTokenType> >(
delegate
{
var actual = analyzer.Analyze <object>(input).Single();
});
// verify exception is coming from expected token
Assert.Equal(ModelGrammar.TokenNone, ex.Token);
}
public void GetTokens_HelloWorld_ReturnsDocument()
{
// input from example at http://bsonspec.org/#/specification
var input = Encoding.UTF8.GetBytes(
"\x16\x00\x00\x00\x02hello\x00" +
"\x06\x00\x00\x00world\x00\x00");
var expected = new[]
{
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty("hello"),
ModelGrammar.TokenPrimitive("world"),
ModelGrammar.TokenObjectEnd
};
var tokenizer = new BsonReader.BsonTokenizer();
var actual = tokenizer.GetTokens(input).ToArray();
Assert.Equal(expected, actual);
}
public void Format_HelloWorld_ReturnsDocument()
{
// input from example at http://bsonspec.org/#/specification
var input = new[]
{
ModelGrammar.TokenObjectBegin("Object"),
ModelGrammar.TokenProperty("hello"),
ModelGrammar.TokenPrimitive("world"),
ModelGrammar.TokenObjectEnd
};
var expected = Encoding.UTF8.GetBytes(
"\x16\x00\x00\x00\x02hello\x00" +
"\x06\x00\x00\x00world\x00\x00");
var formatter = new BsonWriter.BsonFormatter();
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public void GetTokens_MultipleAttributes_ReturnsSequence()
{
const string input = @"<root no-value="""" whitespace="" this contains whitespace "" anyQuotedText=""" + "/\\\uCAFE\uBABE\uAB98\uFCDE\ubcda\uef4A\n\r\t`1~!@#$%^&*()_+-=[]{}|;:',./<>?" + @"""></root>";
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("root")),
MarkupGrammar.TokenAttribute(new DataName("anyQuotedText")),
MarkupGrammar.TokenPrimitive("/\\\uCAFE\uBABE\uAB98\uFCDE\uBCDA\uEF4A `1~!@#$%^&*()_+-=[]{}|;:',./<>?"),
MarkupGrammar.TokenAttribute(new DataName("no-value")),
MarkupGrammar.TokenPrimitive(String.Empty),
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_ObjectAnonymous_ReturnsObjectTokens()
{
var input = new
{
One = 1,
Two = 2,
Three = 3,
Four = new
{
A = 'a',
B = 'b',
C = 'c'
}
};
var expected = new[]
{
ModelGrammar.TokenObjectBegin("object"),
ModelGrammar.TokenProperty("One"),
ModelGrammar.TokenPrimitive(1),
ModelGrammar.TokenProperty("Two"),
ModelGrammar.TokenPrimitive(2),
ModelGrammar.TokenProperty("Three"),
ModelGrammar.TokenPrimitive(3),
ModelGrammar.TokenProperty("Four"),
ModelGrammar.TokenObjectBegin("object"),
ModelGrammar.TokenProperty("A"),
ModelGrammar.TokenPrimitive('a'),
ModelGrammar.TokenProperty("B"),
ModelGrammar.TokenPrimitive('b'),
ModelGrammar.TokenProperty("C"),
ModelGrammar.TokenPrimitive('c'),
ModelGrammar.TokenObjectEnd,
ModelGrammar.TokenObjectEnd
};
var walker = new ModelWalker(new DataWriterSettings());
var actual = walker.GetTokens(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_OverlappingNamespacedTagsErrorRecovery_ReturnsSequenceAsIs()
{
var input = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("odd", "a", "http://example.com/odd/a")),
MarkupGrammar.TokenElementBegin(new DataName("auto-closed", "b", "http://example.com/auto-closed/b")),
MarkupGrammar.TokenElementBegin(new DataName("even", "c", "http://example.com/even/c")),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd
};
var expected = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive("a:odd"),
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty("xmlns:a"),
ModelGrammar.TokenPrimitive("http://example.com/odd/a"),
ModelGrammar.TokenObjectEnd,
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive("b:auto-closed"),
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty("xmlns:b"),
ModelGrammar.TokenPrimitive("http://example.com/auto-closed/b"),
ModelGrammar.TokenObjectEnd,
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive("c:even"),
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty("xmlns:c"),
ModelGrammar.TokenPrimitive("http://example.com/even/c"),
ModelGrammar.TokenObjectEnd,
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenArrayEnd,
};
var converter = new JsonMLReader.JsonMLInTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_ArrayAsProperty_ReturnsDocument()
{
// input from example at http://bsonspec.org/#/specification
// Encoding doesn't seem to like control chars
//var input = Encoding.UTF8.GetBytes(
// "1\x00\x00\x00\x04BSON\x00&\x00"+
// "\x00\x00\x020\x00\x08\x00\x00"+
// "\x00awesome\x00\x011\x00333333"+
// "\x14@\x102\x00\xc2\x07\x00\x00"+
// "\x00\x00");
var input = new byte[]
{
0x31, 0x00, 0x00, 0x00,
0x04, (byte)'B', (byte)'S', (byte)'O', (byte)'N', 0x00,
0x26, 0x00, 0x00, 0x00,
0x02, (byte)'0', 0, 0x08, 0x00, 0x00, 0x00, (byte)'a', (byte)'w', (byte)'e', (byte)'s', (byte)'o', (byte)'m', (byte)'e', 0x00,
0x01, (byte)'1', 0, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x14, 0x40,
0x10, (byte)'2', 0, 0xC2, 0x07, 0x00, 0x00,
0x00,
0x00
};
var expected = new[]
{
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty("BSON"),
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive("awesome"),
ModelGrammar.TokenPrimitive(5.05),
ModelGrammar.TokenPrimitive(1986),
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenObjectEnd
};
var tokenizer = new BsonReader.BsonTokenizer();
var actual = tokenizer.GetTokens(input).ToArray();
Assert.Equal(expected, actual);
}
public void TryWrite_DateTimeMaxValueEcmaScriptPrecision_DirectlyWritesAsUnspecified()
{
var input = DateTime.MaxValue;
var expected = new[]
{
ModelGrammar.TokenPrimitive("9999-12-31T23:59:59.9999999")
};
IEnumerable <Token <ModelTokenType> > actual;
Assert.True(new Iso8601DateFilter {
Format = Iso8601DateFilter.Precision.Ticks
}
.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);
}
public void ArrayItems_MixedPrimitivesFilterAll_ReturnsSplitSequences()
{
var input = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenFalse,
ModelGrammar.TokenTrue,
ModelGrammar.TokenNull,
ModelGrammar.TokenPrimitive("Hello!"),
ModelGrammar.TokenNull,
ModelGrammar.TokenPrimitive(42),
ModelGrammar.TokenArrayEnd
};
var expected = new IEnumerable <Token <ModelTokenType> > [0];
// select no items
var actual = input.ArrayItems(index => false).ToArray();
Assert.Equal(expected, actual, false);
}
public void Format_ArrayOneItemPrettyPrint_ReturnsExpectedPrettyPrintedArray()
{
var input = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenNull,
ModelGrammar.TokenArrayEnd
};
const string expected =
@"[
null
]";
var formatter = new JsonWriter.JsonFormatter(new DataWriterSettings {
PrettyPrint = true
});
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public void GetTokens_BooleanValue_ReturnsDocument()
{
// input from example at http://codebetter.com/blogs/karlseguin/archive/2010/03/05/bson-serialization.aspx
var input = new byte[]
{
13, 0, 0, 0, 8, 118, 97, 108, 105, 100, 0, 1, 0
};
var expected = new[]
{
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty("valid"),
ModelGrammar.TokenTrue,
ModelGrammar.TokenObjectEnd
};
var tokenizer = new BsonReader.BsonTokenizer();
var actual = tokenizer.GetTokens(input).ToArray();
Assert.Equal(expected, actual);
}
public void Format_BooleanValue_ReturnsDocument()
{
// input from example at http://codebetter.com/blogs/karlseguin/archive/2010/03/05/bson-serialization.aspx
var input = new[]
{
ModelGrammar.TokenObjectBegin("Object"),
ModelGrammar.TokenProperty("valid"),
ModelGrammar.TokenTrue,
ModelGrammar.TokenObjectEnd
};
var expected = new byte[]
{
13, 0, 0, 0, 8, 118, 97, 108, 105, 100, 0, 1, 0
};
var formatter = new BsonWriter.BsonFormatter();
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public void Analyze_ObjectUnterminated_ThrowsAnalyzerException()
{
// input from fail32.json in test suite at http://www.json.org/JSON_checker/
var input = new[]
{
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty("Comma instead if closing brace"),
ModelGrammar.TokenTrue
};
var analyzer = new ModelAnalyzer(new DataReaderSettings());
TokenException <ModelTokenType> ex = Assert.Throws <TokenException <ModelTokenType> >(
delegate
{
var actual = analyzer.Analyze <object>(input).Single();
});
// verify exception is coming from expected token
Assert.Equal(ModelGrammar.TokenNone, ex.Token);
}
public void TryWrite_DateTimeMinValueShortPrecision_DirectlyWritesAsUnspecified()
{
var input = DateTime.MinValue;
var expected = new[]
{
ModelGrammar.TokenPrimitive("0001-01-01T00:00:00")
};
IEnumerable <Token <ModelTokenType> > actual;
Assert.True(new Iso8601DateFilter {
Format = Iso8601DateFilter.Precision.Seconds
}
.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);
}
public void Format_ArrayEmpty_ReturnsEmptyArray()
{
var input = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenArrayEnd
};
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("div")),
MarkupGrammar.TokenElementBegin(new DataName("ol")),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd
};
var transformer = new HtmlOutTransformer();
var actual = transformer.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
//[Fact(Skip="Embedded DOCTYPE not supported")]
public void Format_XmlDocTypeLocal_ReturnsUnparsed()
{
var input = new[]
{
MarkupGrammar.TokenUnparsed("!", "",
@"DOCTYPE doc [
<!ATTLIST normId id ID #IMPLIED>
<!ATTLIST normNames attr NMTOKENS #IMPLIED>
]")
};
const string expected =
@"<!DOCTYPE doc [
<!ATTLIST normId id ID #IMPLIED>
<!ATTLIST normNames attr NMTOKENS #IMPLIED>
]>";
var formatter = new HtmlFormatter(new DataWriterSettings());
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public void Analyze_AnonymousObject_ReturnsAnonymousObject()
{
// NOTE: order is important to ensure type equivalence
var input = new[]
{
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty("AString"),
ModelGrammar.TokenPrimitive("Hello world!"),
ModelGrammar.TokenProperty("AnInt32"),
ModelGrammar.TokenPrimitive(42),
ModelGrammar.TokenProperty("AnAnonymous"),
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty("AnotherString"),
ModelGrammar.TokenPrimitive("Foo."),
ModelGrammar.TokenProperty("AnInt64"),
ModelGrammar.TokenPrimitive(((long)Int32.MaxValue) * 2L),
ModelGrammar.TokenObjectEnd,
ModelGrammar.TokenProperty("ADouble"),
ModelGrammar.TokenPrimitive(Math.PI),
ModelGrammar.TokenObjectEnd
};
var expected = new
{
AString = "Hello world!",
AnInt32 = 42,
AnAnonymous = new
{
AnotherString = "Foo.",
AnInt64 = ((long)Int32.MaxValue) * 2L
},
ADouble = Math.PI
};
var analyzer = new ModelAnalyzer(new DataReaderSettings());
var actual = analyzer.Analyze(input, expected).Single();
Assert.Equal(expected, actual, false);
}
public void Query_PropertyNoMatchFirstOrDefault_ReturnsNull()
{
var input = @"
[
{
""key"": ""value""
},
{
""key"": ""other-value""
}
]";
var expected = (object)null;
var source = new JsonReader().Query(input, new { key = String.Empty });
var query = source.Where(obj => obj.key == "not-a-key");
var actual = query.FirstOrDefault();
Assert.Equal(expected, actual, false);
}
public void Format_DifferentPrefixSameNamespace_ReturnsMarkup()
{
// Not sure if this is correct: http://stackoverflow.com/questions/3312390
// "The namespace name for an unprefixed attribute name always has no value"
// "The attribute value in a default namespace declaration MAY be empty.
// This has the same effect, within the scope of the declaration, of there being no default namespace."
// http://www.w3.org/TR/xml-names/#defaulting
var input = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("foo", String.Empty, "http://example.org")),
MarkupGrammar.TokenAttribute(new DataName("key", "blah", "http://example.org")),
MarkupGrammar.TokenPrimitive("value"),
MarkupGrammar.TokenElementEnd,
};
const string expected = @"<foo xmlns=""http://example.org"" key=""value""></foo>";
var formatter = new HtmlFormatter(new DataWriterSettings());
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public void Analyze_ValueInsteadOfProperty_ThrowsAnalyzerException()
{
// input from fail21.json in test suite at http://www.json.org/JSON_checker/
var input = new[]
{
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenPrimitive("Comma instead of colon"),
ModelGrammar.TokenNull,
ModelGrammar.TokenObjectEnd
};
var analyzer = new ModelAnalyzer(new DataReaderSettings());
TokenException <ModelTokenType> ex = Assert.Throws <TokenException <ModelTokenType> >(
delegate
{
var actual = analyzer.Analyze <object>(input).Single();
});
// verify exception is coming from expected token
Assert.Equal(ModelGrammar.TokenPrimitive("Comma instead of colon"), ex.Token);
}
public void Format_ObjectAndAttributeDifferentNamespaces_CorrectlyEmitsNamespaces()
{
var input = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("foo", String.Empty, "http://json.org")),
MarkupGrammar.TokenAttribute(new DataName("key", String.Empty, "http://jsonfx.net", true)),
MarkupGrammar.TokenPrimitive("value"),
MarkupGrammar.TokenElementEnd,
};
var expected = new[]
{
ModelGrammar.TokenObjectBegin(new DataName("foo", String.Empty, "http://json.org")),
ModelGrammar.TokenProperty(new DataName("key", String.Empty, "http://jsonfx.net", true)),
ModelGrammar.TokenPrimitive("value"),
ModelGrammar.TokenObjectEnd
};
var transformer = new XmlReader.XmlInTransformer(new DataReaderSettings());
var actual = transformer.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void Format_ObjectOnePropertyPrettyPrint_ReturnsPrettyPrintedSimpleObject()
{
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 {
PrettyPrint = true
});
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public void Format_NestedDefaultNamespaces_ReturnsMarkup()
{
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,
};
const string expected = @"<outer xmlns=""http://example.org/outer""><middle-1 xmlns=""http://example.org/inner""><inner>this should be inner</inner></middle-1><middle-2>this should be outer</middle-2></outer>";
var formatter = new HtmlFormatter(new DataWriterSettings());
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public void GetTokens_XmlDocTypeExternal_ReturnsUnparsed()
{
var input = new[]
{
ModelGrammar.TokenPrimitive(new UnparsedBlock("!", "",
@"DOCTYPE html PUBLIC
""-//W3C//DTD XHTML 1.1//EN""
""http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd""" ))
};
var expected = new[]
{
MarkupGrammar.TokenUnparsed("!", "",
@"DOCTYPE html PUBLIC
""-//W3C//DTD XHTML 1.1//EN""
""http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd""" )
};
var converter = new JsonMLWriter.JsonMLOutTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void Format_MultipleAttributesCanonicalForm_ReturnsCanonicalMarkup()
{
var input = new[]
{
MarkupGrammar.TokenElementVoid(new DataName("root")),
MarkupGrammar.TokenAttribute(new DataName("whitespace")),
MarkupGrammar.TokenPrimitive(" this contains whitespace "),
MarkupGrammar.TokenAttribute(new DataName("no-value")),
MarkupGrammar.TokenPrimitive(String.Empty),
MarkupGrammar.TokenAttribute(new DataName("anyQuotedText")),
MarkupGrammar.TokenPrimitive("/\\\uCAFE\uBABE\uAB98\uFCDE\ubcda\uef4A\b\f\n\r\t`1~!@#$%^&*()_+-=[]{}|;:',./<>?")
};
const string expected = @"<root anyQuotedText=""/\" + "\uCAFE\uBABE\uAB98\uFCDE\uBCDA\uEF4A" + @"

	`1~!@#$%^&*()_+-=[]{}|;:',./<>?"" no-value whitespace="" this contains whitespace ""></root>";
var formatter = new HtmlFormatter(new DataWriterSettings())
{
CanonicalForm = true
};
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public void Read_AllowTrailingContent_IgnoresTrailingContent()
{
var input = new StringReader(@"[""Content embedded inside other structure"", true,null, 42]</xml>");
var expected = new object[]
{
"Content embedded inside other structure",
true,
null,
42
};
var reader = new JsonReader(new DataReaderSettings {
AllowTrailingContent = true
});
var actual = reader.Read(input);
Assert.Equal(expected, actual);
// Didn't consume remaining content
Assert.Equal("</xml>", input.ReadToEnd());
}
public void GetTokens_MixedEntities_ReturnsSequence()
{
var input = new[]
{
MarkupGrammar.TokenPrimitive(@"there should "),
MarkupGrammar.TokenPrimitive(@"<"),
MarkupGrammar.TokenPrimitive(@"b"),
MarkupGrammar.TokenPrimitive(@">"),
MarkupGrammar.TokenPrimitive(@"e decoded chars "),
MarkupGrammar.TokenPrimitive(@"&"),
MarkupGrammar.TokenPrimitive(@" inside this text")
};
var expected = new[]
{
ModelGrammar.TokenPrimitive(@"there should <b>e decoded chars & inside this text")
};
var converter = new JsonMLReader.JsonMLInTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}