public void WhitespaceCharacterTest()
        {
            /// <summary>
            /// http://www.ietf.org/rfc/rfc4627.txt for JSON whitespace definition (Section 2).
            /// </summary>
            char[] whitespaceCharacters = new char[]
            {
                ' ',
                '\t',
                '\r',
                '\n'
            };

            string input = "[" + " " + "\"hello\"" + "," + "\t" + "\"my\"" + "\r" + "," + "\"name\"" + "\n" + "," + "\"is\"" + "]";

            JsonTokenInfo[] token =
            {
                JsonTokenInfo.ArrayStart(),
                JsonTokenInfo.String("hello"),
                JsonTokenInfo.String("my"),
                JsonTokenInfo.String("name"),
                JsonTokenInfo.String("is"),
                JsonTokenInfo.ArrayEnd(),
            };

            this.PerformRoundTripTest(input, token);
        }
        internal static JsonTokenInfo[] GetTokensWithReader(IJsonReader jsonReader)
        {
            List <JsonTokenInfo> tokens = new List <JsonTokenInfo>();

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

                case JsonTokenType.BeginArray:
                    tokens.Add(JsonTokenInfo.ArrayStart());
                    break;

                case JsonTokenType.EndArray:
                    tokens.Add(JsonTokenInfo.ArrayEnd());
                    break;

                case JsonTokenType.BeginObject:
                    tokens.Add(JsonTokenInfo.ObjectStart());
                    break;

                case JsonTokenType.EndObject:
                    tokens.Add(JsonTokenInfo.ObjectEnd());
                    break;

                case JsonTokenType.String:
                    tokens.Add(JsonTokenInfo.String(jsonReader.GetStringValue()));
                    break;

                case JsonTokenType.Number:
                    tokens.Add(JsonTokenInfo.Number(jsonReader.GetNumberValue()));
                    break;

                case JsonTokenType.True:
                    tokens.Add(JsonTokenInfo.Boolean(true));
                    break;

                case JsonTokenType.False:
                    tokens.Add(JsonTokenInfo.Boolean(false));
                    break;

                case JsonTokenType.Null:
                    tokens.Add(JsonTokenInfo.Null());
                    break;

                case JsonTokenType.FieldName:
                    tokens.Add(JsonTokenInfo.FieldName(jsonReader.GetStringValue()));
                    break;

                default:
                    break;
                }
            }

            return(tokens.ToArray());
        }
Example #3
0
        public static JsonTokenInfo[] Tokenize(IJsonReader jsonReader, string json)
        {
            List <JsonTokenInfo> tokensFromReader = new List <JsonTokenInfo>();

            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(JsonTokenInfo.ArrayStart());
                    break;

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

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

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

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

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

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

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

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

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

                default:
                    break;
                }
            }

            return(tokensFromReader.ToArray());
        }
        public void EmptyArrayTest()
        {
            string input = "[  ]  ";

            JsonTokenInfo[] token =
            {
                JsonTokenInfo.ArrayStart(),
                JsonTokenInfo.ArrayEnd(),
            };

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

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

            this.PerformRoundTripTest(input, token);
        }
        public void NullArrayTest()
        {
            string input = "[ null, null, null]  ";

            JsonTokenInfo[] token =
            {
                JsonTokenInfo.ArrayStart(),
                JsonTokenInfo.Null(),
                JsonTokenInfo.Null(),
                JsonTokenInfo.Null(),
                JsonTokenInfo.ArrayEnd(),
            };

            this.PerformRoundTripTest(input, token);
        }
        public void NumberArrayTest()
        {
            string input = "[15,  22, 0.1]  ";

            JsonTokenInfo[] token =
            {
                JsonTokenInfo.ArrayStart(),
                JsonTokenInfo.Number(15),
                JsonTokenInfo.Number(22),
                JsonTokenInfo.Number(0.1),
                JsonTokenInfo.ArrayEnd(),
            };

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

            JsonTokenInfo[] token =
            {
                JsonTokenInfo.ArrayStart(),
                JsonTokenInfo.ObjectStart(),
                JsonTokenInfo.ObjectEnd(),
                JsonTokenInfo.ObjectStart(),
                JsonTokenInfo.ObjectEnd(),
                JsonTokenInfo.ArrayEnd(),
            };

            this.PerformRoundTripTest(input, token);
        }
        public void IntArrayTest()
        {
            string input = "[ -2, -1, 0, 1, 2]  ";

            JsonTokenInfo[] token =
            {
                JsonTokenInfo.ArrayStart(),
                JsonTokenInfo.Number(-2),
                JsonTokenInfo.Number(-1),
                JsonTokenInfo.Number(0),
                JsonTokenInfo.Number(1),
                JsonTokenInfo.Number(2),
                JsonTokenInfo.ArrayEnd(),
            };

            this.PerformRoundTripTest(input, token);
        }
        internal static JsonTokenInfo[] GetTokensFromArrayNode(IJsonNavigatorNode node, IJsonNavigator navigator, bool performCorrectnessCheck)
        {
            // Get tokens once through IEnumerable
            List <JsonTokenInfo>             tokensFromIEnumerable = new List <JsonTokenInfo>();
            IEnumerable <IJsonNavigatorNode> arrayItems            = navigator.GetArrayItems(node);

            tokensFromIEnumerable.Add(JsonTokenInfo.ArrayStart());
            foreach (IJsonNavigatorNode arrayItem in arrayItems)
            {
                tokensFromIEnumerable.AddRange(JsonNavigatorTests.GetTokensFromNode(arrayItem, navigator, performCorrectnessCheck));
            }

            tokensFromIEnumerable.Add(JsonTokenInfo.ArrayEnd());

            if (performCorrectnessCheck)
            {
                // Get tokens once again through indexer
                List <JsonTokenInfo> tokensFromIndexer = new List <JsonTokenInfo>();
                tokensFromIndexer.Add(JsonTokenInfo.ArrayStart());
                for (int i = 0; i < navigator.GetArrayItemCount(node); ++i)
                {
                    tokensFromIndexer.AddRange(JsonNavigatorTests.GetTokensFromNode(navigator.GetArrayItemAt(node, i), navigator, performCorrectnessCheck));
                }

                tokensFromIndexer.Add(JsonTokenInfo.ArrayEnd());

                Assert.AreEqual(arrayItems.Count(), navigator.GetArrayItemCount(node));
                Assert.IsTrue(tokensFromIEnumerable.SequenceEqual(tokensFromIndexer));

                try
                {
                    navigator.GetArrayItemAt(node, navigator.GetArrayItemCount(node) + 1);
                    Assert.Fail("Expected to get an index out of range exception from going one past the end of the array.");
                }
                catch (IndexOutOfRangeException)
                {
                    Assert.AreEqual(navigator.SerializationFormat, JsonSerializationFormat.Binary);
                }
                catch (ArgumentOutOfRangeException)
                {
                    Assert.AreEqual(navigator.SerializationFormat, JsonSerializationFormat.Text);
                }
            }

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

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

            this.PerformRoundTripTest(input, token);
        }
        public void ArrayLengthLimitsTest()
        {
            // empty array
            string emptyArrayInput = "[]";

            JsonTokenInfo[] emptyArrayTokens =
            {
                JsonTokenInfo.ArrayStart(),
                JsonTokenInfo.ArrayEnd()
            };

            this.PerformRoundTripTest(emptyArrayInput, emptyArrayTokens);

            // single item array
            string singleItemArrayInput = @"[""a""]";

            JsonTokenInfo[] singleItemArrayTokens =
            {
                JsonTokenInfo.ArrayStart(),
                JsonTokenInfo.String("a"),
                JsonTokenInfo.ArrayEnd()
            };

            this.PerformRoundTripTest(singleItemArrayInput, singleItemArrayTokens);

            // max 1 byte length array
            string maxByteLengthPayload = new string('a', byte.MaxValue - 1 - 1);
            string maxByteLengthInput   = @"[""" + maxByteLengthPayload + @"""]";

            JsonTokenInfo[] maxByteLengthTokens =
            {
                JsonTokenInfo.ArrayStart(),
                JsonTokenInfo.String(maxByteLengthPayload),
                JsonTokenInfo.ArrayEnd()
            };

            this.PerformRoundTripTest(maxByteLengthInput, maxByteLengthTokens);

            // max 2 byte length array
            string maxUShortLengthPayload = new string('a', ushort.MaxValue - 1 - 2);
            string maxUShortLengthInput   = @"[""" + maxUShortLengthPayload + @"""]";

            JsonTokenInfo[] maxUShortLengthTokens =
            {
                JsonTokenInfo.ArrayStart(),
                JsonTokenInfo.String(maxUShortLengthPayload),
                JsonTokenInfo.ArrayEnd()
            };

            this.PerformRoundTripTest(maxUShortLengthInput, maxUShortLengthTokens);

            // max 4 byte length array
            string maxUIntLengthPayload = new string('a', ushort.MaxValue);
            string maxUIntLengthInput   = @"[""" + maxUIntLengthPayload + @"""]";

            JsonTokenInfo[] maxUIntLengthTokens =
            {
                JsonTokenInfo.ArrayStart(),
                // 2 of them just to go past int.MaxValue but < uint.MaxValue
                JsonTokenInfo.String(maxUIntLengthPayload),
                JsonTokenInfo.ArrayEnd()
            };

            this.PerformRoundTripTest(maxUIntLengthInput, maxUIntLengthTokens);
        }
        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""
            }";

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

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

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

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

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

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

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

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

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

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

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

            this.PerformRoundTripTest(input, token);
        }