コード例 #1
0
        public void ReadSimpleTypesFromYamlParser()
        {
            // The .NET SDK allows flag data to be read from a YAML file by first running it through a YAML
            // parser, which produces types like Dictionary, and then feeding that into JReader. So we'll
            // verify that a basic use case like that works, using YamlDotNet.
            var yamlContent = @"
---
flags:
  flag1:
    key: flag1
    ""on"": true
    version: 1
    fallthrough:
      variation: 2
    variations:
      - fall
      - ""off""
      - ""on""
flagValues:
  flag2: value2
segments:
  seg1:
    key: seg1
    version: 1
    include: [""user1""]
";
            var yaml        = new YamlDotNet.Serialization.DeserializerBuilder().Build();
            var dataIn      = yaml.Deserialize <object>(yamlContent);

            var r = JReader.FromAdapter(ReaderAdapters.FromSimpleTypes(dataIn));

            var dataOut = JsonStreamConvert.ConvertSimpleTypes.ReadJson(ref r);

            var jsonOut      = JsonStreamConvert.SerializeObject(dataOut, JsonStreamConvert.ConvertSimpleTypes);
            var expectedJson = @"{
""flags"": {
  ""flag1"": {
    ""key"": ""flag1"",
    ""on"": ""true"",
    ""version"": ""1"",
    ""fallthrough"": { ""variation"": ""2"" },
    ""variations"": [ ""fall"", ""off"", ""on"" ]
  }
},
""flagValues"": { ""flag2"": ""value2"" },
""segments"": {
  ""seg1"": { ""key"": ""seg1"", ""version"": ""1"", ""include"": [""user1""] }
}
}";

            // Note that YamlDotNet parses all the booleans and numbers as strings; that's why we provide a
            // type coercion option.
            TestUtil.AssertJsonEqual(expectedJson, jsonOut);
        }
 public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
 {
     // Unfortunately we can't hook directly into an existing Utf8JsonReader, because JReader (like any
     // other type) isn't allowed to retain a reference to a ref struct outside of itself. So we have
     // to parse out the next JSON value or tree all at once, and then wrap it in a delegate object
     // that a JReader can read from. That's less efficient than reading directly from the original
     // reader, due to 1. preallocating the value struct(s) and 2. the overhead of JReader calling the
     // delegate, but it's still better than actually parsing the JSON twice.
     using (JsonDocument jsonDocument = JsonDocument.ParseValue(ref reader))
     {
         var readerWrapper = JReader.FromAdapter(ReaderAdapters.FromJsonElement(jsonDocument.RootElement));
         return((T)_jsonStreamConverter.ReadJson(ref readerWrapper));
     }
 }
コード例 #3
0
        public void ReadFromSimpleTypesWithStrictTypeChecking()
        {
            Assert.True(ParseBool(ReaderAdapters.FromSimpleTypes(true)));
            Assert.False(ParseBool(ReaderAdapters.FromSimpleTypes(false)));
            Assert.Throws <TypeException>(() => ParseBool(ReaderAdapters.FromSimpleTypes("true")));
            Assert.Throws <TypeException>(() => ParseBool(ReaderAdapters.FromSimpleTypes("true")));

            Assert.Equal(100, ParseDouble(ReaderAdapters.FromSimpleTypes(100)));
            Assert.Throws <TypeException>(() => ParseDouble(ReaderAdapters.FromSimpleTypes("100")));

            Assert.Equal("true", ParseString(ReaderAdapters.FromSimpleTypes("true")));
            Assert.Equal("100", ParseString(ReaderAdapters.FromSimpleTypes("100")));
            Assert.Throws <TypeException>(() => ParseString(ReaderAdapters.FromSimpleTypes(true)));
            Assert.Throws <TypeException>(() => ParseString(ReaderAdapters.FromSimpleTypes(100)));
        }
コード例 #4
0
        public void ReadFromSimpleTypesWithTypeCoercion()
        {
            Assert.True(ParseBool(ReaderAdapters.FromSimpleTypes(true, allowTypeCoercion: true)));
            Assert.False(ParseBool(ReaderAdapters.FromSimpleTypes(false, allowTypeCoercion: true)));
            Assert.True(ParseBool(ReaderAdapters.FromSimpleTypes("true", allowTypeCoercion: true)));
            Assert.False(ParseBool(ReaderAdapters.FromSimpleTypes("false", allowTypeCoercion: true)));
            Assert.True(ParseBool(ReaderAdapters.FromSimpleTypes("on", allowTypeCoercion: true)));
            Assert.False(ParseBool(ReaderAdapters.FromSimpleTypes("off", allowTypeCoercion: true)));
            Assert.Throws <TypeException>(() => ParseBool(ReaderAdapters.FromSimpleTypes("x", allowTypeCoercion: true)));

            Assert.Equal(100, ParseDouble(ReaderAdapters.FromSimpleTypes(100, allowTypeCoercion: true)));
            Assert.Equal(100, ParseDouble(ReaderAdapters.FromSimpleTypes("100", allowTypeCoercion: true)));
            Assert.Throws <TypeException>(() => ParseDouble(ReaderAdapters.FromSimpleTypes("x", allowTypeCoercion: true)));

            Assert.Equal("true", ParseString(ReaderAdapters.FromSimpleTypes("true", allowTypeCoercion: true)));
            Assert.Equal("100", ParseString(ReaderAdapters.FromSimpleTypes("100", allowTypeCoercion: true)));
            Assert.Equal("true", ParseString(ReaderAdapters.FromSimpleTypes(true, allowTypeCoercion: true)));
            Assert.Equal("100", ParseString(ReaderAdapters.FromSimpleTypes(100, allowTypeCoercion: true)));
        }
コード例 #5
0
        public void ReadFromSimpleTypes()
        {
            var value = new List <object>
            {
                null,
                true,
                1,
                (long)2,
                3,
                (long)4,
                (float)5.5,
                (double)6.5,
                "x",
                new Dictionary <string, object> {
                    { "a", 1 }
                },
                new Dictionary <object, object> {
                    { "b", 2 }
                }
            };
            var r = JReader.FromAdapter(ReaderAdapters.FromSimpleTypes(value));

            var arr = r.Array();

            Assert.True(arr.Next(ref r));
            r.Null();

            Assert.True(arr.Next(ref r));
            Assert.True(r.Bool());

            Assert.True(arr.Next(ref r));
            Assert.Equal(1, r.Int());

            Assert.True(arr.Next(ref r));
            Assert.Equal(2, r.Int());

            Assert.True(arr.Next(ref r));
            Assert.Equal(3, r.Long());

            Assert.True(arr.Next(ref r));
            Assert.Equal(4, r.Long());

            Assert.True(arr.Next(ref r));
            Assert.Equal(5.5, r.Double());

            Assert.True(arr.Next(ref r));
            Assert.Equal(6.5, r.Double());

            Assert.True(arr.Next(ref r));
            Assert.Equal("x", r.String());

            Assert.True(arr.Next(ref r));
            var obj1 = r.Object();

            Assert.True(obj1.Next(ref r));
            Assert.Equal("a", obj1.Name.ToString());
            Assert.Equal(1, r.Int());
            Assert.False(obj1.Next(ref r));

            Assert.True(arr.Next(ref r));
            var obj2 = r.Object();

            Assert.True(obj2.Next(ref r));
            Assert.Equal("b", obj2.Name.ToString());
            Assert.Equal(2, r.Int());
            Assert.False(obj2.Next(ref r));

            Assert.False(arr.Next(ref r));
            Assert.True(r.EOF);
        }