public void CanConcatenateObjectsViaValueConcatenation_3()
{
var source = @"
data-center-generic = { cluster-size = 6 }
data-center-east = { name = ""east"" } ${data-center-generic}";
var root = JsonPlusParser.Parse(source);
Assert.Equal(6, root.GetInt32("data-center-generic.cluster-size"));
Assert.Equal(6, root.GetInt32("data-center-east.cluster-size"));
Assert.Equal("east", root.GetString("data-center-east.name"));
}
public void CanAssignValuesToPathExpressions()
{
var source = @"
a.b.c=1
a.b.d=2
a.b.e.f=3
";
var root = JsonPlusParser.Parse(source);
Assert.Equal(1L, root.GetInt64("a.b.c"));
Assert.Equal(2L, root.GetInt64("a.b.d"));
Assert.Equal(3L, root.GetInt64("a.b.e.f"));
}
public void EmptyFilesShouldThrows()
{
var ex = Record.Exception(() => JsonPlusParser.Parse(""));
Assert.NotNull(ex);
_output.WriteLine($"Exception message: {ex.Message}");
Assert.IsType <JsonPlusParserException>(ex);
ex = Record.Exception(() => JsonPlusParser.Parse(null));
Assert.NotNull(ex);
Assert.IsType <JsonPlusParserException>(ex);
_output.WriteLine($"Exception message: {ex.Message}");
}
public void ThrowsWhenThereAreNoOverriddenValueAvailable()
{
var source = @"
foo : ${foo}
foo : { a : 1 }
";
var ex = Record.Exception(() => JsonPlusParser.Parse(source));
Assert.NotNull(ex);
Assert.IsType <JsonPlusParserException>(ex);
_output.WriteLine($"Exception message: {ex.Message}");
}
public void CanUsePathsAsKeys_AX_AY()
{
var src1 = @"a.x : 42, a.y : 43";
var src2 = @"a { x : 42, y : 43 }";
Assert.Equal(
JsonPlusParser.Parse(src1).GetString("a.x"),
JsonPlusParser.Parse(src2).GetString("a.x"));
Assert.Equal(
JsonPlusParser.Parse(src1).GetString("a.y"),
JsonPlusParser.Parse(src2).GetString("a.y"));
}
public void FileWithLiteralOnlyShouldThrows()
{
var ex = Record.Exception(() => JsonPlusParser.Parse("literal"));
Assert.NotNull(ex);
Assert.IsType <JsonPlusParserException>(ex);
_output.WriteLine($"Exception message: {ex.Message}");
ex = Record.Exception(() => JsonPlusParser.Parse("${?path}"));
Assert.NotNull(ex);
Assert.IsType <JsonPlusParserException>(ex);
_output.WriteLine($"Exception message: {ex.Message}");
}
public void ObjectCanMixBraceAndDotSyntax()
{
var source = @"
foo { x = 1 }
foo { y = 2 }
foo.z = 32
";
var root = JsonPlusParser.Parse(source);
Assert.Equal(1, root.GetInt32("foo.x"));
Assert.Equal(2, root.GetInt32("foo.y"));
Assert.Equal(32, root.GetInt32("foo.z"));
}
public void ThrowsOnSubstitutionInSubstitution()
{
var source = @"a{
bar = foo
foo = ${?a.${?bar}}
}";
var ex = Record.Exception(() => JsonPlusParser.Parse(source));
Assert.NotNull(ex);
Assert.IsType <JsonPlusParserException>(ex);
_output.WriteLine($"Exception message: {ex.Message}");
}
public void CanOverrideObject()
{
var source = @"
{
foo : { a : 42 },
foo : null,
foo : { b : 43 }
}";
var root = JsonPlusParser.Parse(source);
Assert.False(root.HasPath("foo.a"));
Assert.Equal(43, root.GetInt32("foo.b"));
}
public void ThrowsOnInvalidSubstitutionWithQuestionMarkStartToken_1()
{
var source = @"a{
b = 1
c = ${ ?a.b}
}";
var ex = Record.Exception(() => JsonPlusParser.Parse(source));
Assert.NotNull(ex);
Assert.IsType <JsonPlusParserException>(ex);
_output.WriteLine($"Exception message: {ex.Message}");
}
public void ThrowsOnCyclicSubstitutionDetection_2()
{
var source = @"
a : ${b}
b : ${c}
c : ${a}";
var ex = Record.Exception(() => JsonPlusParser.Parse(source));
Assert.NotNull(ex);
Assert.IsType <JsonPlusParserException>(ex);
_output.WriteLine($"Exception message: {ex.Message}");
}
public void CanAssignArrayToField()
{
var source = @"a=
[
1
2
3
]";
Assert.True(new[] { 1, 2, 3 }.SequenceEqual(JsonPlusParser.Parse(source).GetInt32List("a")));
//source = @"a= [ 1, 2, 3 ]";
//Assert.True(new[] { 1, 2, 3 }.SequenceEqual(Parser.Parse(source).GetIntList("a")));
}
public void ThrowsOnSubstitutionWithQuestionMarkInKeys()
{
var source = @"a{
b = 1
c = b
${?a.c} = 2;
}";
var ex = Record.Exception(() => JsonPlusParser.Parse(source));
Assert.NotNull(ex);
Assert.IsType <JsonPlusParserException>(ex);
_output.WriteLine($"Exception message: {ex.Message}");
}
public void CanParseArrayIncludeInsideArray()
{
var source = @"a : [ include ""foo"" ]";
var includeSrc = @"[1, 2, 3]";
Task <string> IncludeCallback(string s)
=> Task.FromResult(includeSrc);
var config = JsonPlusParser.Parse(source, IncludeCallback);
// TODO: need to figure a better way to retrieve array inside array
var array = config.GetValue("a").GetArray()[0].GetArray().Select(v => v.GetValue().GetInt32());
Assert.True(new[] { 1, 2, 3 }.SequenceEqual(array));
}
public void CanParseByteSize(string value, long?expected)
{
var source = string.Format("byte-size = {0}", value);
var root = JsonPlusParser.Parse(source);
var actual = root.GetByteSize("byte-size");
if (expected.HasValue)
{
Assert.Equal(expected, actual);
}
else
{
Assert.Null(actual);
}
}
public void NewLineCanReplaceCommaInArrays()
{
var source = @"
array_1 : [
1
2
3 ]
array_2 : [1, 2, 3]
";
var root = JsonPlusParser.Parse(source);
Assert.True(
root.GetInt32List("array_1").SequenceEqual(
root.GetInt32List("array_2")));
}
public void CanParseJsonPlusWithSeparatorForObjectFieldAssignment()
{
var source = @"
root {
int = 1
}
root_2 {
unquoted-string = bar
}
";
var root = JsonPlusParser.Parse(source);
Assert.Equal("1", root.GetString("root.int"));
Assert.Equal("bar", root.GetString("root_2.unquoted-string"));
}
public void CanUnwrapSubConfig() //undefined behavior in spec
{
var source = @"
a {
b {
c = 1
d = true
}
}";
var root = JsonPlusParser.Parse(source).Value.GetObject().Unwrapped;
var a = root["a"] as IDictionary <string, object>;
var b = a["b"] as IDictionary <string, object>;
Assert.Equal(1, (b["c"] as JsonPlusObjectMember).Value.GetInt32());
Assert.True((b["d"] as JsonPlusObjectMember).Value.GetBoolean());
}
public void SubstitutionToAnotherMemberOfTheSameObjectAreResolvedNormally()
{
var source = @"
bar : { foo : 42,
baz : ${bar.foo}
}
bar : { foo : 43 }";
JsonPlusRoot root = null;
var ex = Record.Exception(() => root = JsonPlusParser.Parse(source));
Assert.Null(ex);
Assert.Equal(43, root.GetInt32("bar.foo"));
Assert.Equal(43, root.GetInt32("bar.baz"));
}
public void MergedSubstitutionShouldAlwaysResolveToOlderValue()
{
var source = @"
foo : { a : { c : 1 } }
foo : ${foo.a}
foo : { a : 2 }";
JsonPlusRoot root = null;
var ex = Record.Exception(() => root = JsonPlusParser.Parse(source));
Assert.Null(ex);
Assert.Equal(2, root.GetInt32("foo.a"));
Assert.Equal(1, root.GetInt32("foo.c"));
Assert.False(root.HasPath("foo.a.c"));
}
public void CanParseJsonPlusWithRootBraces()
{
var source = @"
{
root {
int = 1
quoted-string = ""foo""
unquoted-string = bar
concat-string = foo bar
object {
hasContent = true
}
array = [1,2,3,4]
array-concat = [[1,2] [3,4]]
array-single-element = [1 2 3 4]
array-newline-element = [
1
2
3
4
]
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.quoted-string"));
Assert.Equal("bar", root.GetString("root.unquoted-string"));
Assert.Equal("foo bar", root.GetString("root.concat-string"));
Assert.True(
new[] { 1, 2, 3, 4 }.SequenceEqual(JsonPlusParser.Parse(source).GetInt32List("root.array")));
Assert.True(
new[] { 1, 2, 3, 4 }.SequenceEqual(
JsonPlusParser.Parse(source).GetInt32List("root.array-newline-element")));
Assert.True(
new[] { "1 2 3 4" }.SequenceEqual(
JsonPlusParser.Parse(source).GetStringList("root.array-single-element")));
Assert.Equal("1234", root.GetString("root_2"));
}
public void ShouldFallbackToEnvironmentVariables()
{
var source = @"a {
b = ${MY_ENV_VAR}
}";
var value = "Environment_Var";
Environment.SetEnvironmentVariable("MY_ENV_VAR", value);
try
{
Assert.Equal(value, JsonPlusParser.Parse(source, null, true).GetString("a.b"));
}
finally
{
Environment.SetEnvironmentVariable("MY_ENV_VAR", null);
}
}
public void CanCSubstituteObject()
{
var source = @"a {
b {
foo = hello
bar = 123
}
c {
d = xyz
e = ${a.b}
}
}";
var root = JsonPlusParser.Parse(source);
Assert.Equal("hello", root.GetString("a.c.e.foo"));
Assert.Equal(123, root.GetInt32("a.c.e.bar"));
}
public void CanMergeObject()
{
var source = @"
a.b.c = {
x = 1
y = 2
}
a.b.c = {
z = 3
}
";
var root = JsonPlusParser.Parse(source);
Assert.Equal("1", root.GetString("a.b.c.x"));
Assert.Equal("2", root.GetString("a.b.c.y"));
Assert.Equal("3", root.GetString("a.b.c.z"));
}
public void KeyNameCanContainSubstitutionPath()
{
var source = @"
foo {
x = 32
}
bar {
foo = ${foo}
}
daz {
foo = ${foo.x}
}
";
var root = JsonPlusParser.Parse(source);
Assert.Equal(32, root.GetInt32("bar.foo.x"));
Assert.Equal(32, root.GetInt32("daz.foo"));
}
public void MutuallyReferringObjectsAreResolvedNormally()
{
var source = @"
// bar.a should end up as 4
bar : { a : ${foo.d}, b : 1 }
bar.b = 3
// foo.c should end up as 3
foo : { c : ${bar.b}, d : 2 }
foo.d = 4";
JsonPlusRoot root = null;
var ex = Record.Exception(() => root = JsonPlusParser.Parse(source));
Assert.Null(ex);
Assert.Equal(4, root.GetInt32("bar.a"));
Assert.Equal(3, root.GetInt32("foo.c"));
}
public void CanAssignNumbersToField()
{
var source = @"
a = 1000.05
b = infinity
c = -infinity
d = +infinity
e = NaN
f = 255
g = 0xff
h = 0377
";
var root = JsonPlusParser.Parse(source);
Assert.Equal(1000.05, root.GetDouble("a"));
Assert.Equal(double.PositiveInfinity, root.GetDouble("b"));
Assert.Equal(double.NegativeInfinity, root.GetDouble("c"));
Assert.Equal(double.PositiveInfinity, root.GetDouble("d"));
Assert.Equal(double.NaN, root.GetDouble("e"));
Assert.Equal(1000.05f, root.GetSingle("a"));
Assert.Equal(float.PositiveInfinity, root.GetSingle("b"));
Assert.Equal(float.NegativeInfinity, root.GetSingle("c"));
Assert.Equal(float.PositiveInfinity, root.GetSingle("d"));
Assert.Equal(float.NaN, root.GetSingle("e"));
Assert.Equal(1000.05m, root.GetDecimal("a"));
Assert.Throws <JsonPlusException>(() => root.GetDecimal("b"));
Assert.Throws <JsonPlusException>(() => root.GetDecimal("c"));
Assert.Throws <JsonPlusException>(() => root.GetDecimal("d"));
Assert.Equal(255, root.GetInt64("f"));
Assert.Equal(255, root.GetInt64("g"));
Assert.Equal(255, root.GetInt64("h"));
Assert.Equal(255, root.GetInt32("f"));
Assert.Equal(255, root.GetInt32("g"));
Assert.Equal(255, root.GetInt32("h"));
Assert.Equal(255, root.GetByte("f"));
Assert.Equal(255, root.GetByte("g"));
Assert.Equal(255, root.GetByte("h"));
}
public void OptionalIncludeSuppressError()
{
Task <string> includeCallback(string path)
=> Task.FromResult(string.Empty);
var source = @"
include ""foo""
";
Assert.Throws <JsonPlusParserException>(() => JsonPlusParser.Parse(source, includeCallback));
var source2 = @"
include? ""foo""
";
var config = JsonPlusParser.Parse(source2, includeCallback);
Assert.True(config.IsEmpty);
}
public void NullValueQuestionMarkSubstitutionShouldNotLookUpExternalSource()
{
var source = @"
MY_ENV_VAR = null
a {
b = ${?MY_ENV_VAR}
}";
var value = "Environment_Var";
Environment.SetEnvironmentVariable("MY_ENV_VAR", value);
try
{
Assert.Null(JsonPlusParser.Parse(source).GetString("a.b"));
}
finally
{
Environment.SetEnvironmentVariable("MY_ENV_VAR", null);
}
}
public void CanAssignBooleanToField()
{
var source = @"a=true";
Assert.True(JsonPlusParser.Parse(source).GetBoolean("a"));
source = @"a=false";
Assert.False(JsonPlusParser.Parse(source).GetBoolean("a"));
// deprecated keywords on/off
//source = @"a=on";
//Assert.True(JsonPlusParser.Parse(source).GetBoolean("a"));
//source = @"a=off";
//Assert.False(JsonPlusParser.Parse(source).GetBoolean("a"));
source = @"a=yes";
Assert.True(JsonPlusParser.Parse(source).GetBoolean("a"));
source = @"a=no";
Assert.False(JsonPlusParser.Parse(source).GetBoolean("a"));
}
