public void CanAssignValueToPathExpression()
{
var source = @"a.b.c=1";
var root = JsonPlusParser.Parse(source);
Assert.Equal(1L, root.GetInt64("a.b.c"));
}
public void SubstitutionPathMustBeFullyQualified()
{
var source = @"
foo = outerhello
bar {
foo = innerhello
suba = ${foo}
subb = ${bar.foo}
}
";
var root = JsonPlusParser.Parse(source);
Assert.Equal("outerhello", root.GetString("bar.suba"));
Assert.Equal("innerhello", root.GetString("bar.subb"));
var source2 = @"
foo {
bar = hello
suba = ${bar}
}
";
var ex = Record.Exception(() => JsonPlusParser.Parse(source2));
Assert.NotNull(ex);
Assert.IsType <JsonPlusParserException>(ex);
_output.WriteLine($"Exception message: {ex.Message}");
}
public void CanParseJsonWithNoRootBraces()
{
var source = @"
""root"" : {
""int"" : 1,
""string"" : ""foo"",
""object"" : {
""hasContent"" : true
},
""array"" : [1,2,3],
""null"" : null,
""double"" : 1.23,
""bool"" : true
},
""root_2"" : 1234";
var root = JsonPlusParser.Parse(source);
Assert.Equal("1", root.GetString("root.int"));
Assert.Equal("1.23", root.GetString("root.double"));
Assert.True(root.GetBoolean("root.bool"));
Assert.True(root.GetBoolean("root.object.hasContent"));
Assert.Null(root.GetString("root.null"));
Assert.Equal("foo", root.GetString("root.string"));
Assert.True(new[] { 1, 2, 3 }.SequenceEqual(JsonPlusParser.Parse(source).GetInt32List("root.array")));
Assert.Equal("1234", root.GetString("root_2"));
}
public void GettingArrayFromLiteralsReturnsNull() //undefined behavior in spec
{
var source = " literal : a b c";
var res = JsonPlusParser.Parse(source).GetStringList("literal");
Assert.Empty(res);
}
public void CanMergeObject_RecursiveMerging()
{
var source = @"
foo
{
bar
{
a : 42
b : 43
}
},
foo
{
bar
{
b : 44
c : 45
baz
{
a : 9000
}
}
}
";
var root = JsonPlusParser.Parse(source);
Assert.Equal(42, root.GetInt32("foo.bar.a"));
Assert.Equal(44, root.GetInt32("foo.bar.b"));
Assert.Equal(45, root.GetInt32("foo.bar.c"));
Assert.Equal(9000, root.GetInt32("foo.bar.baz.a"));
}
public void PlusEqualOperatorShouldExpandToSelfReferencingArrayConcatenation()
{
var source1 = @"
a = [ 1, 2 ]
a += 3
a += [4, 5]
";
var root1 = JsonPlusParser.Parse(source1);
Assert.True(new[] { 1, 2, 3, 4, 5 }.SequenceEqual(root1.GetInt32List("a")));
var source = @"
a = [ 1, 2 ]
a += 3
a += ${b}
b = [ 4, 5 ]
";
JsonPlusRoot root = null;
var ex = Record.Exception(() => root = JsonPlusParser.Parse(source));
Assert.Null(ex);
Assert.True(new [] { 1, 2, 3, 4, 5 }.SequenceEqual(root.GetInt32List("a")));
}
public void ShouldRemoveAllTrailingWhitespace()
{
var source = $"a = literal value{WhitespaceDef.Whitespaces}";
var root = JsonPlusParser.Parse(source);
Assert.Equal("literal value", root.GetString("a"));
}
public void SubstitutionChangeValueByPath()
{
/*
* var source = @"
* foo = dummy
* subfoo = ${foo}sub1
* subbar = ${foo}sub2
* deep {
* subfoo = ${foo}subx
* subbar = ${foo}suby
* }
* subbar = world
* ";
*/
var source = @"
foo = dummy
subfoo = ${foo}sub1
deep {
subfoo = ${foo}subx
subbar = ${foo}suby
}
subbar = ${foo}sub2
subbar = world
";
var root = JsonPlusParser.Parse(source);
Assert.Equal("dummy", root.GetString("foo"));
Assert.Equal("dummysub1", root.GetString("subfoo"));
Assert.Equal("dummysubx", root.GetString("deep.subfoo"));
Assert.Equal("dummysuby", root.GetString("deep.subbar"));
Assert.Equal("world", root.GetString("subbar"));
}
public void ArrayItemSupportObjectSubstitution()
{
/*
* var source = @"
* foo {
* x = 123
* }
* bar = ${foo}{ y = 456 }
* ";
* var root = JsonPlusParser.Parse(source);
* Assert.Equal(123, root.GetInt32("bar.x"));
* Assert.Equal(456, root.GetInt32("bar.y"));
*/
var source = @"
foo {
x = 123
}
bar = [${foo}, ${foo}{ y = 456 }]
";
var root = JsonPlusParser.Parse(source);
var barValue = root.GetValue("bar").GetArray();
Assert.Equal(123, barValue[0].GetObject()["x"].GetValue().GetInt32());
Assert.Equal(123, barValue[1].GetObject()["x"].GetValue().GetInt32());
Assert.Equal(456, barValue[1].GetObject()["y"].GetValue().GetInt32());
}
public void ShouldPreserveWhitespacesInTheMiddle()
{
var source = $"a = literal{WhitespaceDef.Whitespaces}value";
var root = JsonPlusParser.Parse(source);
Assert.Equal($"literal{WhitespaceDef.Whitespaces}value", root.GetString("a"));
}
public void CanConcatenateArray()
{
var source = @"a=[1,2] [3,4]";
Assert.True(
new[] { 1, 2, 3, 4 }.SequenceEqual(
JsonPlusParser.Parse(source).GetInt32List("a")));
}
public void UndefinedQuestionMarkShouldFailSilently()
{
var source = @"a {
b = ${?a.c}
}";
JsonPlusParser.Parse(source);
}
public void SimpleSubstitutionBetweenBracketsShouldResolveToArray(string bar, string[] expected)
{
var source = $@"foo = hello
bar = {bar}";
var root = JsonPlusParser.Parse(source);
Assert.Equal(expected, root.GetStringList("bar").ToArray());
}
public void UndefinedQuestionMarkSubstitutionShouldResolveToEmptyArray()
{
var source = @"a {
c = ${?a.b} [4,5,6]
}";
Assert.True(new[] { 4, 5, 6 }.SequenceEqual(JsonPlusParser.Parse(source).GetInt32List("a.c")));
}
public void CanConcatenateObjectsViaValueConcatenation_1()
{
var source = "a : { b : 1 } { c : 2 }";
var root = JsonPlusParser.Parse(source);
Assert.Equal(1, root.GetInt32("a.b"));
Assert.Equal(2, root.GetInt32("a.c"));
}
public void CanUsePathsAsKeys_3_14()
{
var src1 = @"3.14 : 42";
var src2 = @"3 { 14 : 42}";
Assert.Equal(
JsonPlusParser.Parse(src1).GetString("3.14"),
JsonPlusParser.Parse(src2).GetString("3.14"));
}
public void CanUsePathsAsKeys_true()
{
var src1 = @"true : 42";
var src2 = @"""true"" : 42";
Assert.Equal(
JsonPlusParser.Parse(src1).GetString("true"),
JsonPlusParser.Parse(src2).GetString("true"));
}
public void TwoUndefinedQuestionMarkSubstitutionShouldNotCreateField()
{
var source = @"a{
foo = ${?bar}${?baz}
}";
var root = JsonPlusParser.Parse(source);
Assert.False(root.HasPath("a.foo"));
}
public void UndefinedQuestionMarkSubstitutionShouldResolveToEmptyString()
{
var source = @"a{
b = My name is ${?foo}
}";
var root = JsonPlusParser.Parse(source);
Assert.Equal("My name is ", root.GetString("a.b"));
}
public void UndefinedQuestionMarkSubstitutionShouldNotAddArrayElement()
{
var source = @"a{
b = [ 1, ${?foo}, 3, 4 ]
}";
var root = JsonPlusParser.Parse(source);
Assert.True(new[] { 1, 3, 4 }.SequenceEqual(root.GetInt32List("a.b")));
}
public void CanUsePathsAsKeys_3()
{
var src1 = @"3 : 42";
var src2 = @"""3"" : 42";
Assert.Equal(
JsonPlusParser.Parse(src1).GetString("3"),
JsonPlusParser.Parse(src2).GetString("3"));
}
public void DoNotParseSubstitutionInsideQuotedString()
{
var source = @"a{
b = 5
c = ""I have ${a.b} Tesla car(s).""
}";
Assert.Equal("I have ${a.b} Tesla car(s).", JsonPlusParser.Parse(source).GetString("a.c"));
}
public void CanUsePathsAsKeys_FooBarBaz()
{
var src1 = @"foo.bar.baz : 42";
var src2 = @"foo { bar { baz : 42 } }";
Assert.Equal(
JsonPlusParser.Parse(src1).GetString("foo.bar.baz"),
JsonPlusParser.Parse(src2).GetString("foo.bar.baz"));
}
public void CanUsePathsAsKeys_A_B_C()
{
var src1 = @"a b c : 42";
var src2 = @"""a b c"" : 42";
Assert.Equal(
JsonPlusParser.Parse(src1).GetString("a b c"),
JsonPlusParser.Parse(src2).GetString("a b c"));
}
public void CanConcatenateQuotedString()
{
var source = @"a {
name = Roger
c = ""Hello my name is ""${a.name}
}";
Assert.Equal("Hello my name is Roger", JsonPlusParser.Parse(source).GetString("a.c"));
}
public void ExtraCommaAtTheEndIgnored()
{
var src1 = @"a:1, b:2, c:3,";
var src2 = @"a:1, b:2, c:3";
Assert.True(
JsonPlusParser.Parse(src1).AsEnumerable().SequenceEqual(
JsonPlusParser.Parse(src2).AsEnumerable()));
}
public void ThrowsParserExceptionOnIllegalCommaInFrontOfArray()
{
var source = @"array : [, 1, 2, 3]";
var ex = Record.Exception(() => JsonPlusParser.Parse(source));
Assert.NotNull(ex);
Assert.IsType <JsonPlusParserException>(ex);
_output.WriteLine($"Exception message: {ex.Message}");
}
public void ThrowsParserExceptionOnMultipleTrailingCommasInArray()
{
var source = @"array : [1, 2, 3,, ]";
var ex = Record.Exception(() => JsonPlusParser.Parse(source));
Assert.NotNull(ex);
Assert.IsType <JsonPlusParserException>(ex);
_output.WriteLine($"Exception message: {ex.Message}");
}
public void ThrowsParserExceptionOnMultipleCommas()
{
var source = @"{a:1,, b:2, c:3}";
var ex = Record.Exception(() => JsonPlusParser.Parse(source));
Assert.NotNull(ex);
Assert.IsType <JsonPlusParserException>(ex);
_output.WriteLine($"Exception message: {ex.Message}");
}
public void CanConcatenateArray_2()
{
var source = @"a {
b = [4,5,6]
c = [1,2,3] ${a.b}
}";
var root = JsonPlusParser.Parse(source);
Assert.True(new[] { 1, 2, 3, 4, 5, 6 }.SequenceEqual(root.GetInt32List("a.c")));
}
