public void JsonArrayItemsFunctionalTest()
        {
            int seed = 1;

            for (int i = 0; i < iterationCount / 10; i++)
            {
                seed++;
                Log.Info("Seed: {0}", seed);
                Random rndGen   = new Random(seed);
                bool   retValue = true;

                // JsonArray.Contains(JsonValue)
                // JsonArray.IndexOf(JsonValue)
                JsonArray sourceJson = SpecialJsonValueHelper.CreatePrePopulatedJsonArray(seed, arrayLength);
                for (int j = 0; j < sourceJson.Count; j++)
                {
                    if (!sourceJson.Contains(sourceJson[j]))
                    {
                        Log.Info("[JsonArrayItemsFunctionalTest] JsonArray.Contains(JsonValue) failed to function properly.");
                        retValue = false;
                    }
                    else
                    {
                        Log.Info("[JsonArrayItemsFunctionalTest] JsonArray.Contains(JsonValue) passed test.");
                    }

                    if (sourceJson.IndexOf(sourceJson[j]) != j)
                    {
                        Log.Info("[JsonArrayItemsFunctionalTest] JsonArray.IndexOf(JsonValue) failed to function properly.");
                        retValue = false;
                    }
                    else
                    {
                        Log.Info("[JsonArrayItemsFunctionalTest] JsonArray.IndexOf(JsonValue) passed test.");
                    }
                }

                // JsonArray.Insert(int, JsonValue)
                JsonValue newItem = SpecialJsonValueHelper.GetRandomJsonPrimitives(seed);
                sourceJson.Insert(3, newItem);
                if (sourceJson[3] != newItem || sourceJson.Count != arrayLength + 1)
                {
                    Log.Info("[JsonArrayItemsFunctionalTest] JsonArray.Insert(int, JsonValue) failed to function properly.");
                    retValue = false;
                }
                else
                {
                    Log.Info("[JsonArrayItemsFunctionalTest] JsonArray.Insert(int, JsonValue) passed test.");
                }

                Assert.True(retValue);
            }
        }
Пример #2
0
        public void InsertTest()
        {
            JsonValue item1  = AnyInstance.AnyJsonValue1;
            JsonValue item2  = AnyInstance.AnyJsonValue2;
            JsonValue item3  = AnyInstance.AnyJsonValue3;
            JsonArray target = new JsonArray(item1);

            Assert.Equal(1, target.Count);
            target.Insert(0, item2);
            Assert.Equal(2, target.Count);
            Assert.Equal(item2, target[0]);
            Assert.Equal(item1, target[1]);

            target.Insert(1, item3);
            Assert.Equal(3, target.Count);
            Assert.Equal(item2, target[0]);
            Assert.Equal(item3, target[1]);
            Assert.Equal(item1, target[2]);

            target.Insert(target.Count, item2);
            Assert.Equal(4, target.Count);
            Assert.Equal(item2, target[0]);
            Assert.Equal(item3, target[1]);
            Assert.Equal(item1, target[2]);
            Assert.Equal(item2, target[3]);

            ExceptionHelper.Throws <ArgumentOutOfRangeException>(() => target.Insert(-1, item3));
            ExceptionHelper.Throws <ArgumentOutOfRangeException>(() => target.Insert(target.Count + 1, item1));
            ExceptionHelper.Throws <ArgumentException>(() => target.Insert(0, AnyInstance.DefaultJsonValue));
        }
Пример #3
0
        public void JsonArrayEventsTest()
        {
            int       seed           = 1;
            const int maxArrayLength = 1024;
            Random    rand           = new Random(seed);
            JsonArray ja             = SpecialJsonValueHelper.CreatePrePopulatedJsonArray(seed, rand.Next(maxArrayLength));
            int       addPosition    = ja.Count;
            JsonValue insertValue    = SpecialJsonValueHelper.GetRandomJsonPrimitives(seed);

            TestEvents(
                ja,
                arr => arr.Add(insertValue),
                new List <Tuple <bool, JsonValue, JsonValueChangeEventArgs> >
            {
                new Tuple <bool, JsonValue, JsonValueChangeEventArgs>(true, ja, new JsonValueChangeEventArgs(insertValue, JsonValueChange.Add, addPosition)),
                new Tuple <bool, JsonValue, JsonValueChangeEventArgs>(false, ja, new JsonValueChangeEventArgs(insertValue, JsonValueChange.Add, addPosition)),
            });

            addPosition = ja.Count;
            JsonValue jv1 = SpecialJsonValueHelper.GetRandomJsonPrimitives(seed);
            JsonValue jv2 = SpecialJsonValueHelper.GetRandomJsonPrimitives(seed);

            TestEvents(
                ja,
                arr => arr.AddRange(jv1, jv2),
                new List <Tuple <bool, JsonValue, JsonValueChangeEventArgs> >
            {
                new Tuple <bool, JsonValue, JsonValueChangeEventArgs>(true, ja,
                                                                      new JsonValueChangeEventArgs(
                                                                          jv1,
                                                                          JsonValueChange.Add, addPosition)),
                new Tuple <bool, JsonValue, JsonValueChangeEventArgs>(true, ja,
                                                                      new JsonValueChangeEventArgs(
                                                                          jv2,
                                                                          JsonValueChange.Add, addPosition + 1)),
                new Tuple <bool, JsonValue, JsonValueChangeEventArgs>(false, ja,
                                                                      new JsonValueChangeEventArgs(
                                                                          jv1,
                                                                          JsonValueChange.Add, addPosition)),
                new Tuple <bool, JsonValue, JsonValueChangeEventArgs>(false, ja,
                                                                      new JsonValueChangeEventArgs(
                                                                          jv2,
                                                                          JsonValueChange.Add, addPosition + 1)),
            });

            int       replacePosition = rand.Next(ja.Count - 1);
            JsonValue oldValue        = ja[replacePosition];
            JsonValue newValue        = SpecialJsonValueHelper.GetRandomJsonPrimitives(seed);

            TestEvents(
                ja,
                arr => arr[replacePosition] = newValue,
                new List <Tuple <bool, JsonValue, JsonValueChangeEventArgs> >
            {
                new Tuple <bool, JsonValue, JsonValueChangeEventArgs>(true, ja, new JsonValueChangeEventArgs(newValue, JsonValueChange.Replace, replacePosition)),
                new Tuple <bool, JsonValue, JsonValueChangeEventArgs>(false, ja, new JsonValueChangeEventArgs(oldValue, JsonValueChange.Replace, replacePosition)),
            });

            int insertPosition = rand.Next(ja.Count - 1);

            insertValue = SpecialJsonValueHelper.GetRandomJsonPrimitives(seed);

            TestEvents(
                ja,
                arr => arr.Insert(insertPosition, insertValue),
                new List <Tuple <bool, JsonValue, JsonValueChangeEventArgs> >
            {
                new Tuple <bool, JsonValue, JsonValueChangeEventArgs>(true, ja, new JsonValueChangeEventArgs(insertValue, JsonValueChange.Add, insertPosition)),
                new Tuple <bool, JsonValue, JsonValueChangeEventArgs>(false, ja, new JsonValueChangeEventArgs(insertValue, JsonValueChange.Add, insertPosition)),
            });

            TestEvents(
                ja,
                arr => arr.RemoveAt(insertPosition),
                new List <Tuple <bool, JsonValue, JsonValueChangeEventArgs> >
            {
                new Tuple <bool, JsonValue, JsonValueChangeEventArgs>(true, ja, new JsonValueChangeEventArgs(insertValue, JsonValueChange.Remove, insertPosition)),
                new Tuple <bool, JsonValue, JsonValueChangeEventArgs>(false, ja, new JsonValueChangeEventArgs(insertValue, JsonValueChange.Remove, insertPosition)),
            });

            ja.Insert(0, insertValue);
            TestEvents(
                ja,
                arr => arr.Remove(insertValue),
                new List <Tuple <bool, JsonValue, JsonValueChangeEventArgs> >
            {
                new Tuple <bool, JsonValue, JsonValueChangeEventArgs>(true, ja, new JsonValueChangeEventArgs(insertValue, JsonValueChange.Remove, 0)),
                new Tuple <bool, JsonValue, JsonValueChangeEventArgs>(false, ja, new JsonValueChangeEventArgs(insertValue, JsonValueChange.Remove, 0)),
            });

            TestEvents(
                ja,
                arr => arr.Clear(),
                new List <Tuple <bool, JsonValue, JsonValueChangeEventArgs> >
            {
                new Tuple <bool, JsonValue, JsonValueChangeEventArgs>(true, ja, new JsonValueChangeEventArgs(null, JsonValueChange.Clear, 0)),
                new Tuple <bool, JsonValue, JsonValueChangeEventArgs>(false, ja, new JsonValueChangeEventArgs(null, JsonValueChange.Clear, 0)),
            });

            ja = new JsonArray(1, 2, 3);
            TestEvents(
                ja,
                arr => arr.Remove(new JsonPrimitive("Not there")),
                new List <Tuple <bool, JsonValue, JsonValueChangeEventArgs> >());

            JsonValue elementInArray = ja[1];

            TestEvents(
                ja,
                arr => arr.Remove(elementInArray),
                new List <Tuple <bool, JsonValue, JsonValueChangeEventArgs> >
            {
                new Tuple <bool, JsonValue, JsonValueChangeEventArgs>(true, ja, new JsonValueChangeEventArgs(elementInArray, JsonValueChange.Remove, 1)),
                new Tuple <bool, JsonValue, JsonValueChangeEventArgs>(false, ja, new JsonValueChangeEventArgs(elementInArray, JsonValueChange.Remove, 1)),
            });
        }