Пример #1
0
        private static JsonToken[] GetTokensFromNode(IJsonNavigatorNode node, IJsonNavigator navigator, bool performCorrectnessCheck)
        {
            switch (navigator.GetNodeType(node))
            {
            case JsonNodeType.Null:
                return(new JsonToken[] { JsonToken.Null() });

            case JsonNodeType.False:
                return(new JsonToken[] { JsonToken.Boolean(false) });

            case JsonNodeType.True:
                return(new JsonToken[] { JsonToken.Boolean(true) });

            case JsonNodeType.Number64:
                return(new JsonToken[] { JsonToken.Number(navigator.GetNumber64Value(node)) });

            case JsonNodeType.String:
                return(new JsonToken[] { JsonToken.String(navigator.GetStringValue(node)) });

            case JsonNodeType.Array:
                return(JsonNavigatorTests.GetTokensFromArrayNode(node, navigator, performCorrectnessCheck));

            case JsonNodeType.Object:
                return(JsonNavigatorTests.GetTokensFromObjectNode(node, navigator, performCorrectnessCheck));

            case JsonNodeType.FieldName:
                return(new JsonToken[] { JsonToken.FieldName(navigator.GetStringValue(node)) });

            case JsonNodeType.Int8:
                return(new JsonToken[] { JsonToken.Int8(navigator.GetInt8Value(node)) });

            case JsonNodeType.Int16:
                return(new JsonToken[] { JsonToken.Int16(navigator.GetInt16Value(node)) });

            case JsonNodeType.Int32:
                return(new JsonToken[] { JsonToken.Int32(navigator.GetInt32Value(node)) });

            case JsonNodeType.Int64:
                return(new JsonToken[] { JsonToken.Int64(navigator.GetInt64Value(node)) });

            case JsonNodeType.UInt32:
                return(new JsonToken[] { JsonToken.UInt32(navigator.GetUInt32Value(node)) });

            case JsonNodeType.Float32:
                return(new JsonToken[] { JsonToken.Float32(navigator.GetFloat32Value(node)) });

            case JsonNodeType.Float64:
                return(new JsonToken[] { JsonToken.Float64(navigator.GetFloat64Value(node)) });

            case JsonNodeType.Guid:
                return(new JsonToken[] { JsonToken.Guid(navigator.GetGuidValue(node)) });

            case JsonNodeType.Binary:
                return(new JsonToken[] { JsonToken.Binary(navigator.GetBinaryValue(node)) });

            default:
                throw new InvalidOperationException();
            }
        }
Пример #2
0
        public static JsonToken[] Tokenize(IJsonReader jsonReader, string json)
        {
            List <JsonToken> tokensFromReader = new List <JsonToken>();

            while (jsonReader.Read())
            {
                switch (jsonReader.CurrentTokenType)
                {
                case JsonTokenType.NotStarted:
                    throw new ArgumentException(string.Format("Got an unexpected JsonTokenType: {0} as an expected token type", jsonReader.CurrentTokenType));

                case JsonTokenType.BeginArray:
                    tokensFromReader.Add(JsonToken.ArrayStart());
                    break;

                case JsonTokenType.EndArray:
                    tokensFromReader.Add(JsonToken.ArrayEnd());
                    break;

                case JsonTokenType.BeginObject:
                    tokensFromReader.Add(JsonToken.ObjectStart());
                    break;

                case JsonTokenType.EndObject:
                    tokensFromReader.Add(JsonToken.ObjectEnd());
                    break;

                case JsonTokenType.String:
                    tokensFromReader.Add(JsonToken.String(jsonReader.GetStringValue()));
                    break;

                case JsonTokenType.Number:
                    tokensFromReader.Add(JsonToken.Number(jsonReader.GetNumberValue()));
                    break;

                case JsonTokenType.True:
                    tokensFromReader.Add(JsonToken.Boolean(true));
                    break;

                case JsonTokenType.False:
                    tokensFromReader.Add(JsonToken.Boolean(false));
                    break;

                case JsonTokenType.Null:
                    tokensFromReader.Add(JsonToken.Null());
                    break;

                case JsonTokenType.FieldName:
                    tokensFromReader.Add(JsonToken.FieldName(jsonReader.GetStringValue()));
                    break;

                default:
                    break;
                }
            }

            return(tokensFromReader.ToArray());
        }
        public void FalseTest()
        {
            string input = "false";

            JsonToken[] token =
            {
                JsonToken.Boolean(false)
            };

            this.PerformRoundTripTest(input, token);
        }
        public void TrueTest()
        {
            string input = "true";

            JsonToken[] token =
            {
                JsonToken.Boolean(true)
            };

            this.PerformRoundTripTest(input, token);
        }
        public void BooleanArrayTest()
        {
            string input = "[ true, false]  ";

            JsonToken[] token =
            {
                JsonToken.ArrayStart(),
                JsonToken.Boolean(true),
                JsonToken.Boolean(false),
                JsonToken.ArrayEnd(),
            };

            this.PerformRoundTripTest(input, token);
        }
        public void AllPrimitiveArrayTest()
        {
            string input = "[0, 0.1, -1, -1.1, 1, 2, \"hello\", null, true, false]  ";

            JsonToken[] token =
            {
                JsonToken.ArrayStart(),
                JsonToken.Number(0),
                JsonToken.Number(0.1),
                JsonToken.Number(-1),
                JsonToken.Number(-1.1),
                JsonToken.Number(1),
                JsonToken.Number(2),
                JsonToken.String("hello"),
                JsonToken.Null(),
                JsonToken.Boolean(true),
                JsonToken.Boolean(false),
                JsonToken.ArrayEnd(),
            };

            this.PerformRoundTripTest(input, token);
        }
Пример #7
0
        private static JsonToken[] GetTokensWithReader(IJsonReader jsonReader)
        {
            List <JsonToken> tokens = new List <JsonToken>();

            while (jsonReader.Read())
            {
                JsonToken token;
                switch (jsonReader.CurrentTokenType)
                {
                case JsonTokenType.NotStarted:
                    throw new InvalidOperationException();

                case JsonTokenType.BeginArray:
                    token = JsonToken.ArrayStart();
                    break;

                case JsonTokenType.EndArray:
                    token = JsonToken.ArrayEnd();
                    break;

                case JsonTokenType.BeginObject:
                    token = JsonToken.ObjectStart();
                    break;

                case JsonTokenType.EndObject:
                    token = JsonToken.ObjectEnd();
                    break;

                case JsonTokenType.String:
                    token = JsonToken.String(jsonReader.GetStringValue());
                    break;

                case JsonTokenType.Number:
                    token = JsonToken.Number(jsonReader.GetNumberValue());
                    break;

                case JsonTokenType.True:
                    token = JsonToken.Boolean(true);
                    break;

                case JsonTokenType.False:
                    token = JsonToken.Boolean(false);
                    break;

                case JsonTokenType.Null:
                    token = JsonToken.Null();
                    break;

                case JsonTokenType.FieldName:
                    token = JsonToken.FieldName(jsonReader.GetStringValue());
                    break;

                case JsonTokenType.Int8:
                    token = JsonToken.Int8(jsonReader.GetInt8Value());
                    break;

                case JsonTokenType.Int16:
                    token = JsonToken.Int16(jsonReader.GetInt16Value());
                    break;

                case JsonTokenType.Int32:
                    token = JsonToken.Int32(jsonReader.GetInt32Value());
                    break;

                case JsonTokenType.Int64:
                    token = JsonToken.Int64(jsonReader.GetInt64Value());
                    break;

                case JsonTokenType.UInt32:
                    token = JsonToken.UInt32(jsonReader.GetUInt32Value());
                    break;

                case JsonTokenType.Float32:
                    token = JsonToken.Float32(jsonReader.GetFloat32Value());
                    break;

                case JsonTokenType.Float64:
                    token = JsonToken.Float64(jsonReader.GetFloat64Value());
                    break;

                case JsonTokenType.Guid:
                    token = JsonToken.Guid(jsonReader.GetGuidValue());
                    break;

                case JsonTokenType.Binary:
                    token = JsonToken.Binary(jsonReader.GetBinaryValue());
                    break;

                default:
                    throw new ArgumentException($"Unknown {nameof(JsonTokenType)}: {jsonReader.CurrentTokenType}");
                }

                tokens.Add(token);
            }

            return(tokens.ToArray());
        }
        public void AllPrimitivesObjectTest()
        {
            string input = @"{
                ""id"": ""7029d079-4016-4436-b7da-36c0bae54ff6"",
                ""double"": 0.18963001816981939,
                ""int"": -1330192615,
                ""string"": ""XCPCFXPHHF"",
                ""boolean"": true,
                ""null"": null,
                ""datetime"": ""2526-07-11T18:18:16.4520716"",
                ""spatialPoint"": {
                    ""type"": ""Point"",
                    ""coordinates"": [
                        118.9897,
                        -46.6781
                    ]
                },
                ""text"": ""tiger diamond newbrunswick snowleopard chocolate dog snowleopard turtle cat sapphire peach sapphire vancouver white chocolate horse diamond lion superlongcolourname ruby""
            }";

            JsonToken[] token =
            {
                JsonToken.ObjectStart(),

                JsonToken.FieldName("id"),
                JsonToken.String("7029d079-4016-4436-b7da-36c0bae54ff6"),

                JsonToken.FieldName("double"),
                JsonToken.Number(0.18963001816981939),

                JsonToken.FieldName("int"),
                JsonToken.Number(-1330192615),

                JsonToken.FieldName("string"),
                JsonToken.String("XCPCFXPHHF"),

                JsonToken.FieldName("boolean"),
                JsonToken.Boolean(true),

                JsonToken.FieldName("null"),
                JsonToken.Null(),

                JsonToken.FieldName("datetime"),
                JsonToken.String("2526-07-11T18:18:16.4520716"),

                JsonToken.FieldName("spatialPoint"),
                JsonToken.ObjectStart(),
                JsonToken.FieldName("type"),
                JsonToken.String("Point"),

                JsonToken.FieldName("coordinates"),
                JsonToken.ArrayStart(),
                JsonToken.Number(118.9897),
                JsonToken.Number(-46.6781),
                JsonToken.ArrayEnd(),
                JsonToken.ObjectEnd(),

                JsonToken.FieldName("text"),
                JsonToken.String("tiger diamond newbrunswick snowleopard chocolate dog snowleopard turtle cat sapphire peach sapphire vancouver white chocolate horse diamond lion superlongcolourname ruby"),
                JsonToken.ObjectEnd(),
            };

            this.PerformRoundTripTest(input, token);
        }