You've already forked linux-packaging-mono
acceptance-tests
data
debian
docs
external
Newtonsoft.Json
api-doc-tools
api-snapshot
aspnetwebstack
packages
src
test
Microsoft.TestCommon
Microsoft.Web.Helpers.Test
Microsoft.Web.Http.Data.Test
Microsoft.Web.Mvc.Test
Microsoft.Web.WebPages.OAuth.Test
SPA.Test
System.Json.Test.Integration
System.Json.Test.Unit
Common
Extensions
Properties
JsonArrayTest.cs
JsonDefaultTest.cs
JsonObjectTest.cs
JsonPrimitiveTest.cs
JsonTypeTest.cs
JsonValueDynamicMetaObjectTest.cs
JsonValueDynamicTest.cs
JsonValueLinqExtensionsTest.cs
JsonValueTest.cs
System.Json.Test.Unit.csproj
packages.config
System.Net.Http.Formatting.Test.Integration
System.Net.Http.Formatting.Test.Unit
System.Web.Helpers.Test
System.Web.Http.Integration.Test
System.Web.Http.SelfHost.Test
System.Web.Http.Test
System.Web.Http.WebHost.Test
System.Web.Mvc.Test
System.Web.Razor.Test
System.Web.WebPages.Administration.Test
System.Web.WebPages.Deployment.Test
System.Web.WebPages.Razor.Test
System.Web.WebPages.Test
WebMatrix.Data.Test
WebMatrix.WebData.Test
Settings.StyleCop
tools
.gitattributes
.gitignore
License.txt
README.md
Runtime.msbuild
Runtime.sln
Runtime.xunit
Settings.StyleCop
build.cmd
binary-reference-assemblies
bockbuild
boringssl
cecil
cecil-legacy
corefx
corert
ikdasm
ikvm
linker
nuget-buildtasks
nunit-lite
roslyn-binaries
rx
xunit-binaries
ikvm-native
libgc
llvm
m4
man
mcs
mono
msvc
po
runtime
samples
scripts
support
tools
COPYING.LIB
LICENSE
Makefile.am
Makefile.in
NEWS
README.md
acinclude.m4
aclocal.m4
autogen.sh
code_of_conduct.md
compile
config.guess
config.h.in
config.rpath
config.sub
configure.REMOVED.git-id
configure.ac.REMOVED.git-id
depcomp
install-sh
ltmain.sh.REMOVED.git-id
missing
mkinstalldirs
mono-uninstalled.pc.in
test-driver
winconfig.h
607 lines
26 KiB
C#
607 lines
26 KiB
C#
// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
|
|
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Runtime.Serialization.Json;
|
|
using Xunit;
|
|
|
|
namespace System.Json
|
|
{
|
|
public class JsonArrayTest
|
|
{
|
|
[Fact]
|
|
public void JsonArrayConstructorParamsTest()
|
|
{
|
|
JsonArray target;
|
|
|
|
target = new JsonArray();
|
|
Assert.Equal(0, target.Count);
|
|
|
|
target = new JsonArray(null);
|
|
Assert.Equal(0, target.Count);
|
|
|
|
List<JsonValue> items = new List<JsonValue> { AnyInstance.AnyJsonValue1, AnyInstance.AnyJsonValue2 };
|
|
target = new JsonArray(items.ToArray());
|
|
ValidateJsonArrayItems(target, items);
|
|
|
|
target = new JsonArray(items[0], items[1]);
|
|
ValidateJsonArrayItems(target, items);
|
|
|
|
// Invalide tests
|
|
items.Add(AnyInstance.DefaultJsonValue);
|
|
ExceptionHelper.Throws<ArgumentException>(() => new JsonArray(items.ToArray()));
|
|
ExceptionHelper.Throws<ArgumentException>(() => new JsonArray(items[0], items[1], items[2]));
|
|
}
|
|
|
|
[Fact]
|
|
public void JsonArrayConstructorEnumTest()
|
|
{
|
|
List<JsonValue> items = new List<JsonValue> { AnyInstance.AnyJsonValue1, AnyInstance.AnyJsonValue2, AnyInstance.AnyJsonValue3 };
|
|
JsonArray target;
|
|
|
|
target = new JsonArray(items);
|
|
ValidateJsonArrayItems(target, items);
|
|
|
|
ExceptionHelper.Throws<ArgumentNullException>(() => new JsonArray((IEnumerable<JsonValue>)null));
|
|
|
|
items.Add(AnyInstance.DefaultJsonValue);
|
|
ExceptionHelper.Throws<ArgumentException>(() => new JsonArray(items));
|
|
}
|
|
|
|
[Fact]
|
|
public void AddTest()
|
|
{
|
|
JsonArray target = new JsonArray();
|
|
JsonValue item = AnyInstance.AnyJsonValue1;
|
|
Assert.False(target.Contains(item));
|
|
target.Add(item);
|
|
Assert.Equal(1, target.Count);
|
|
Assert.Equal(item, target[0]);
|
|
Assert.True(target.Contains(item));
|
|
|
|
ExceptionHelper.Throws<ArgumentException>(() => target.Add(AnyInstance.DefaultJsonValue));
|
|
}
|
|
|
|
[Fact]
|
|
public void AddRangeEnumTest()
|
|
{
|
|
List<JsonValue> items = new List<JsonValue> { AnyInstance.AnyJsonValue1, AnyInstance.AnyJsonValue2 };
|
|
|
|
JsonArray target = new JsonArray();
|
|
target.AddRange(items);
|
|
ValidateJsonArrayItems(target, items);
|
|
|
|
ExceptionHelper.Throws<ArgumentNullException>(() => new JsonArray().AddRange((IEnumerable<JsonValue>)null));
|
|
|
|
items.Add(AnyInstance.DefaultJsonValue);
|
|
ExceptionHelper.Throws<ArgumentException>(() => new JsonArray().AddRange(items));
|
|
}
|
|
|
|
[Fact]
|
|
public void AddRangeParamsTest()
|
|
{
|
|
List<JsonValue> items = new List<JsonValue> { AnyInstance.AnyJsonValue1, AnyInstance.AnyJsonValue2, AnyInstance.AnyJsonValue3 };
|
|
JsonArray target;
|
|
|
|
target = new JsonArray();
|
|
target.AddRange(items[0], items[1], items[2]);
|
|
ValidateJsonArrayItems(target, items);
|
|
|
|
target = new JsonArray();
|
|
target.AddRange(items.ToArray());
|
|
ValidateJsonArrayItems(target, items);
|
|
|
|
target.AddRange();
|
|
ValidateJsonArrayItems(target, items);
|
|
|
|
items.Add(AnyInstance.DefaultJsonValue);
|
|
ExceptionHelper.Throws<ArgumentException>(() => new JsonArray().AddRange(items[items.Count - 1]));
|
|
ExceptionHelper.Throws<ArgumentException>(() => new JsonArray().AddRange(items));
|
|
}
|
|
|
|
[Fact]
|
|
public void ClearTest()
|
|
{
|
|
JsonArray target = new JsonArray(AnyInstance.AnyJsonValue1, AnyInstance.AnyJsonValue2);
|
|
Assert.Equal(2, target.Count);
|
|
target.Clear();
|
|
Assert.Equal(0, target.Count);
|
|
}
|
|
|
|
[Fact]
|
|
public void ContainsTest()
|
|
{
|
|
JsonValue item1 = AnyInstance.AnyJsonValue1;
|
|
JsonValue item2 = AnyInstance.AnyJsonValue2;
|
|
JsonArray target = new JsonArray(item1);
|
|
Assert.True(target.Contains(item1));
|
|
Assert.False(target.Contains(item2));
|
|
|
|
target.Add(item2);
|
|
Assert.True(target.Contains(item1));
|
|
Assert.True(target.Contains(item2));
|
|
|
|
target.Remove(item1);
|
|
Assert.False(target.Contains(item1));
|
|
Assert.True(target.Contains(item2));
|
|
}
|
|
|
|
[Fact]
|
|
public void ReadAsComplexTypeTest()
|
|
{
|
|
JsonArray target = new JsonArray(AnyInstance.AnyInt, AnyInstance.AnyInt + 1, AnyInstance.AnyInt + 2);
|
|
int[] intArray1 = (int[])target.ReadAsType(typeof(int[]));
|
|
int[] intArray2 = target.ReadAsType<int[]>();
|
|
|
|
Assert.Equal(((JsonArray)target).Count, intArray1.Length);
|
|
Assert.Equal(((JsonArray)target).Count, intArray2.Length);
|
|
|
|
for (int i = 0; i < intArray1.Length; i++)
|
|
{
|
|
Assert.Equal(AnyInstance.AnyInt + i, intArray1[i]);
|
|
Assert.Equal(AnyInstance.AnyInt + i, intArray2[i]);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void CopyToTest()
|
|
{
|
|
JsonValue item1 = AnyInstance.AnyJsonValue1;
|
|
JsonValue item2 = AnyInstance.AnyJsonValue2;
|
|
JsonArray target = new JsonArray(item1, item2);
|
|
JsonValue[] array = new JsonValue[target.Count + 1];
|
|
|
|
target.CopyTo(array, 0);
|
|
Assert.Equal(item1, array[0]);
|
|
Assert.Equal(item2, array[1]);
|
|
|
|
target.CopyTo(array, 1);
|
|
Assert.Equal(item1, array[1]);
|
|
Assert.Equal(item2, array[2]);
|
|
|
|
ExceptionHelper.Throws<ArgumentNullException>(() => target.CopyTo(null, 0));
|
|
ExceptionHelper.Throws<ArgumentOutOfRangeException>(() => target.CopyTo(array, -1));
|
|
ExceptionHelper.Throws<ArgumentException>(() => target.CopyTo(array, array.Length - target.Count + 1));
|
|
}
|
|
|
|
[Fact]
|
|
public void IndexOfTest()
|
|
{
|
|
JsonValue item1 = AnyInstance.AnyJsonValue1;
|
|
JsonValue item2 = AnyInstance.AnyJsonValue2;
|
|
JsonValue item3 = AnyInstance.AnyJsonValue3;
|
|
JsonArray target = new JsonArray(item1, item2);
|
|
|
|
Assert.Equal(0, target.IndexOf(item1));
|
|
Assert.Equal(1, target.IndexOf(item2));
|
|
Assert.Equal(-1, target.IndexOf(item3));
|
|
}
|
|
|
|
[Fact]
|
|
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));
|
|
}
|
|
|
|
[Fact]
|
|
public void RemoveTest()
|
|
{
|
|
JsonValue item1 = AnyInstance.AnyJsonValue1;
|
|
JsonValue item2 = AnyInstance.AnyJsonValue2;
|
|
JsonValue item3 = AnyInstance.AnyJsonValue3;
|
|
JsonArray target = new JsonArray(item1, item2, item3);
|
|
|
|
Assert.True(target.Remove(item2));
|
|
Assert.Equal(2, target.Count);
|
|
Assert.Equal(item1, target[0]);
|
|
Assert.Equal(item3, target[1]);
|
|
|
|
Assert.False(target.Remove(item2));
|
|
Assert.Equal(2, target.Count);
|
|
}
|
|
|
|
[Fact]
|
|
public void RemoveAtTest()
|
|
{
|
|
JsonValue item1 = AnyInstance.AnyJsonValue1;
|
|
JsonValue item2 = AnyInstance.AnyJsonValue2;
|
|
JsonValue item3 = AnyInstance.AnyJsonValue3;
|
|
JsonArray target = new JsonArray(item1, item2, item3);
|
|
|
|
target.RemoveAt(1);
|
|
Assert.Equal(2, target.Count);
|
|
Assert.Equal(item1, target[0]);
|
|
Assert.Equal(item3, target[1]);
|
|
|
|
ExceptionHelper.Throws<ArgumentOutOfRangeException>(() => target.RemoveAt(-1));
|
|
ExceptionHelper.Throws<ArgumentOutOfRangeException>(() => target.RemoveAt(target.Count));
|
|
}
|
|
|
|
[Fact]
|
|
public void ToStringTest()
|
|
{
|
|
JsonArray target;
|
|
JsonValue item1 = AnyInstance.AnyJsonValue1;
|
|
JsonValue item2 = null;
|
|
JsonValue item3 = AnyInstance.AnyJsonValue2;
|
|
|
|
target = new JsonArray(item1, item2, item3);
|
|
|
|
string expected = String.Format(CultureInfo.InvariantCulture, "[{0},null,{1}]", item1.ToString(), item3.ToString());
|
|
Assert.Equal(expected, target.ToString());
|
|
|
|
string json = "[\r\n \"hello\",\r\n null,\r\n [\r\n 1,\r\n 2,\r\n 3\r\n ]\r\n]";
|
|
target = JsonValue.Parse(json) as JsonArray;
|
|
|
|
Assert.Equal<string>(json.Replace("\r\n", "").Replace(" ", ""), target.ToString());
|
|
}
|
|
|
|
[Fact]
|
|
public void GetEnumeratorTest()
|
|
{
|
|
JsonValue item1 = AnyInstance.AnyJsonValue1;
|
|
JsonValue item2 = AnyInstance.AnyJsonValue2;
|
|
|
|
IEnumerable<JsonValue> target = new JsonArray(item1, item2);
|
|
IEnumerator<JsonValue> enumerator = target.GetEnumerator();
|
|
Assert.True(enumerator.MoveNext());
|
|
Assert.Equal(item1, enumerator.Current);
|
|
Assert.True(enumerator.MoveNext());
|
|
Assert.Equal(item2, enumerator.Current);
|
|
Assert.False(enumerator.MoveNext());
|
|
}
|
|
|
|
[Fact]
|
|
public void GetEnumeratorTest1()
|
|
{
|
|
JsonValue item1 = AnyInstance.AnyJsonValue1;
|
|
JsonValue item2 = AnyInstance.AnyJsonValue2;
|
|
|
|
IEnumerable target = new JsonArray(item1, item2);
|
|
IEnumerator enumerator = target.GetEnumerator();
|
|
Assert.True(enumerator.MoveNext());
|
|
Assert.Equal(item1, enumerator.Current);
|
|
Assert.True(enumerator.MoveNext());
|
|
Assert.Equal(item2, enumerator.Current);
|
|
Assert.False(enumerator.MoveNext());
|
|
}
|
|
|
|
[Fact]
|
|
public void CountTest()
|
|
{
|
|
JsonValue item1 = AnyInstance.AnyJsonValue1;
|
|
JsonValue item2 = AnyInstance.AnyJsonValue2;
|
|
|
|
JsonArray target = new JsonArray();
|
|
Assert.Equal(0, target.Count);
|
|
target.Add(item1);
|
|
Assert.Equal(1, target.Count);
|
|
target.Add(item2);
|
|
Assert.Equal(2, target.Count);
|
|
target.Remove(item1);
|
|
Assert.Equal(1, target.Count);
|
|
}
|
|
|
|
[Fact]
|
|
public void IsReadOnlyTest()
|
|
{
|
|
JsonArray target = AnyInstance.AnyJsonArray;
|
|
Assert.False(target.IsReadOnly);
|
|
}
|
|
|
|
[Fact]
|
|
public void ItemTest()
|
|
{
|
|
JsonValue item1 = AnyInstance.AnyJsonValue1;
|
|
JsonValue item2 = AnyInstance.AnyJsonValue2;
|
|
|
|
JsonArray target = new JsonArray(item1);
|
|
Assert.Equal(item1, target[0]);
|
|
target[0] = item2;
|
|
Assert.Equal(item2, target[0]);
|
|
Assert.Equal(item2, target[(short)0]);
|
|
Assert.Equal(item2, target[(ushort)0]);
|
|
Assert.Equal(item2, target[(byte)0]);
|
|
Assert.Equal(item2, target[(sbyte)0]);
|
|
Assert.Equal(item2, target[(char)0]);
|
|
|
|
ExceptionHelper.Throws<ArgumentOutOfRangeException>(delegate { var i = target[-1]; });
|
|
ExceptionHelper.Throws<ArgumentOutOfRangeException>(delegate { var i = target[target.Count]; });
|
|
ExceptionHelper.Throws<ArgumentOutOfRangeException>(delegate { target[-1] = AnyInstance.AnyJsonValue1; });
|
|
ExceptionHelper.Throws<ArgumentOutOfRangeException>(delegate { target[target.Count] = AnyInstance.AnyJsonValue2; });
|
|
ExceptionHelper.Throws<ArgumentException>(delegate { target[0] = AnyInstance.DefaultJsonValue; });
|
|
}
|
|
|
|
[Fact]
|
|
public void ChangingEventsTest()
|
|
{
|
|
JsonArray ja = new JsonArray(AnyInstance.AnyInt, AnyInstance.AnyBool, null);
|
|
TestEvents(
|
|
ja,
|
|
arr => arr.Add(1),
|
|
new List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>>
|
|
{
|
|
new Tuple<bool, JsonValue, JsonValueChangeEventArgs>(true, ja, new JsonValueChangeEventArgs(1, JsonValueChange.Add, 3)),
|
|
new Tuple<bool, JsonValue, JsonValueChangeEventArgs>(false, ja, new JsonValueChangeEventArgs(1, JsonValueChange.Add, 3)),
|
|
});
|
|
|
|
TestEvents(
|
|
ja,
|
|
arr => arr.AddRange(AnyInstance.AnyString, AnyInstance.AnyDouble),
|
|
new List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>>
|
|
{
|
|
new Tuple<bool, JsonValue, JsonValueChangeEventArgs>(true, ja, new JsonValueChangeEventArgs(AnyInstance.AnyString, JsonValueChange.Add, 4)),
|
|
new Tuple<bool, JsonValue, JsonValueChangeEventArgs>(true, ja, new JsonValueChangeEventArgs(AnyInstance.AnyDouble, JsonValueChange.Add, 5)),
|
|
new Tuple<bool, JsonValue, JsonValueChangeEventArgs>(false, ja, new JsonValueChangeEventArgs(AnyInstance.AnyString, JsonValueChange.Add, 4)),
|
|
new Tuple<bool, JsonValue, JsonValueChangeEventArgs>(false, ja, new JsonValueChangeEventArgs(AnyInstance.AnyDouble, JsonValueChange.Add, 5)),
|
|
});
|
|
|
|
TestEvents(
|
|
ja,
|
|
arr => arr[1] = 2,
|
|
new List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>>
|
|
{
|
|
new Tuple<bool, JsonValue, JsonValueChangeEventArgs>(true, ja, new JsonValueChangeEventArgs(2, JsonValueChange.Replace, 1)),
|
|
new Tuple<bool, JsonValue, JsonValueChangeEventArgs>(false, ja, new JsonValueChangeEventArgs(AnyInstance.AnyBool, JsonValueChange.Replace, 1)),
|
|
});
|
|
|
|
ja = new JsonArray { 1, 2, 3 };
|
|
TestEvents(
|
|
ja,
|
|
arr => arr.Insert(1, "new value"),
|
|
new List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>>
|
|
{
|
|
new Tuple<bool, JsonValue, JsonValueChangeEventArgs>(true, ja, new JsonValueChangeEventArgs("new value", JsonValueChange.Add, 1)),
|
|
new Tuple<bool, JsonValue, JsonValueChangeEventArgs>(false, ja, new JsonValueChangeEventArgs("new value", JsonValueChange.Add, 1)),
|
|
});
|
|
|
|
TestEvents(
|
|
ja,
|
|
arr => arr.RemoveAt(1),
|
|
new List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>>
|
|
{
|
|
new Tuple<bool, JsonValue, JsonValueChangeEventArgs>(true, ja, new JsonValueChangeEventArgs("new value", JsonValueChange.Remove, 1)),
|
|
new Tuple<bool, JsonValue, JsonValueChangeEventArgs>(false, ja, new JsonValueChangeEventArgs("new value", JsonValueChange.Remove, 1)),
|
|
});
|
|
|
|
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)),
|
|
});
|
|
}
|
|
|
|
[Fact]
|
|
public void NestedChangingEventTest()
|
|
{
|
|
JsonArray target = new JsonArray { new JsonArray { 1, 2 }, new JsonArray { 3, 4 } };
|
|
JsonArray child = target[1] as JsonArray;
|
|
TestEvents(
|
|
target,
|
|
arr => ((JsonArray)arr[1]).Add(5),
|
|
new List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>>());
|
|
|
|
target = new JsonArray();
|
|
child = new JsonArray(1, 2);
|
|
TestEvents(
|
|
target,
|
|
arr =>
|
|
{
|
|
arr.Add(child);
|
|
((JsonArray)arr[0]).Add(5);
|
|
},
|
|
new List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>>
|
|
{
|
|
new Tuple<bool, JsonValue, JsonValueChangeEventArgs>(true, target, new JsonValueChangeEventArgs(child, JsonValueChange.Add, 0)),
|
|
new Tuple<bool, JsonValue, JsonValueChangeEventArgs>(false, target, new JsonValueChangeEventArgs(child, JsonValueChange.Add, 0)),
|
|
});
|
|
}
|
|
|
|
[Fact]
|
|
public void MultipleListenersTest()
|
|
{
|
|
for (int changingListeners = 0; changingListeners <= 2; changingListeners++)
|
|
{
|
|
for (int changedListeners = 0; changedListeners <= 2; changedListeners++)
|
|
{
|
|
MultipleListenersTestHelper<JsonArray>(
|
|
() => new JsonArray(1, 2),
|
|
delegate(JsonArray arr)
|
|
{
|
|
arr[1] = "hello";
|
|
arr.RemoveAt(0);
|
|
arr.Add("world");
|
|
arr.Clear();
|
|
},
|
|
new List<JsonValueChangeEventArgs>
|
|
{
|
|
new JsonValueChangeEventArgs("hello", JsonValueChange.Replace, 1),
|
|
new JsonValueChangeEventArgs(1, JsonValueChange.Remove, 0),
|
|
new JsonValueChangeEventArgs("world", JsonValueChange.Add, 1),
|
|
new JsonValueChangeEventArgs(null, JsonValueChange.Clear, 0),
|
|
},
|
|
new List<JsonValueChangeEventArgs>
|
|
{
|
|
new JsonValueChangeEventArgs(2, JsonValueChange.Replace, 1),
|
|
new JsonValueChangeEventArgs(1, JsonValueChange.Remove, 0),
|
|
new JsonValueChangeEventArgs("world", JsonValueChange.Add, 1),
|
|
new JsonValueChangeEventArgs(null, JsonValueChange.Clear, 0),
|
|
},
|
|
changingListeners,
|
|
changedListeners);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void JsonTypeTest()
|
|
{
|
|
JsonArray target = AnyInstance.AnyJsonArray;
|
|
Assert.Equal(JsonType.Array, target.JsonType);
|
|
}
|
|
|
|
internal static void TestEvents<JsonValueType>(JsonValueType target, Action<JsonValueType> actionToTriggerEvent, List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>> expectedEvents) where JsonValueType : JsonValue
|
|
{
|
|
List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>> actualEvents = new List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>>();
|
|
EventHandler<JsonValueChangeEventArgs> changingHandler = delegate(object sender, JsonValueChangeEventArgs e)
|
|
{
|
|
actualEvents.Add(new Tuple<bool, JsonValue, JsonValueChangeEventArgs>(true, sender as JsonValue, e));
|
|
};
|
|
|
|
EventHandler<JsonValueChangeEventArgs> changedHandler = delegate(object sender, JsonValueChangeEventArgs e)
|
|
{
|
|
actualEvents.Add(new Tuple<bool, JsonValue, JsonValueChangeEventArgs>(false, sender as JsonValue, e));
|
|
};
|
|
|
|
target.Changing += new EventHandler<JsonValueChangeEventArgs>(changingHandler);
|
|
target.Changed += new EventHandler<JsonValueChangeEventArgs>(changedHandler);
|
|
|
|
actionToTriggerEvent(target);
|
|
|
|
target.Changing -= new EventHandler<JsonValueChangeEventArgs>(changingHandler);
|
|
target.Changed -= new EventHandler<JsonValueChangeEventArgs>(changedHandler);
|
|
|
|
ValidateExpectedEvents(expectedEvents, actualEvents);
|
|
}
|
|
|
|
private static void TestEvents(JsonArray array, Action<JsonArray> actionToTriggerEvent, List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>> expectedEvents)
|
|
{
|
|
TestEvents<JsonArray>(array, actionToTriggerEvent, expectedEvents);
|
|
}
|
|
|
|
private static void ValidateExpectedEvents(List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>> expectedEvents, List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>> actualEvents)
|
|
{
|
|
Assert.Equal(expectedEvents.Count, actualEvents.Count);
|
|
for (int i = 0; i < expectedEvents.Count; i++)
|
|
{
|
|
bool expectedIsChanging = expectedEvents[i].Item1;
|
|
bool actualIsChanging = expectedEvents[i].Item1;
|
|
Assert.Equal(expectedIsChanging, actualIsChanging);
|
|
|
|
JsonValue expectedSender = expectedEvents[i].Item2;
|
|
JsonValue actualSender = actualEvents[i].Item2;
|
|
Assert.Same(expectedSender, actualSender);
|
|
|
|
JsonValueChangeEventArgs expectedEventArgs = expectedEvents[i].Item3;
|
|
JsonValueChangeEventArgs actualEventArgs = actualEvents[i].Item3;
|
|
Assert.Equal(expectedEventArgs.Change, actualEventArgs.Change);
|
|
Assert.Equal(expectedEventArgs.Index, actualEventArgs.Index);
|
|
Assert.Equal(expectedEventArgs.Key, actualEventArgs.Key);
|
|
|
|
string expectedChild = expectedEventArgs.Child == null ? "null" : expectedEventArgs.Child.ToString();
|
|
string actualChild = actualEventArgs.Child == null ? "null" : actualEventArgs.Child.ToString();
|
|
Assert.Equal(expectedChild, actualChild);
|
|
}
|
|
}
|
|
|
|
internal static void MultipleListenersTestHelper<JsonValueType>(
|
|
Func<JsonValueType> createTarget,
|
|
Action<JsonValueType> actionToTriggerEvents,
|
|
List<JsonValueChangeEventArgs> expectedChangingEventArgs,
|
|
List<JsonValueChangeEventArgs> expectedChangedEventArgs,
|
|
int changingListeners,
|
|
int changedListeners) where JsonValueType : JsonValue
|
|
{
|
|
Console.WriteLine("Testing events on a {0} for {1} changING listeners and {2} changED listeners", typeof(JsonValueType).Name, changingListeners, changedListeners);
|
|
JsonValueType target = createTarget();
|
|
List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>>[] actualChangingEvents = new List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>>[changingListeners];
|
|
List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>>[] actualChangedEvents = new List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>>[changedListeners];
|
|
List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>> expectedChangingEvents = new List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>>(
|
|
expectedChangingEventArgs.Select((args) => new Tuple<bool, JsonValue, JsonValueChangeEventArgs>(true, target, args)));
|
|
List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>> expectedChangedEvents = new List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>>(
|
|
expectedChangedEventArgs.Select((args) => new Tuple<bool, JsonValue, JsonValueChangeEventArgs>(false, target, args)));
|
|
|
|
for (int i = 0; i < changingListeners; i++)
|
|
{
|
|
actualChangingEvents[i] = new List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>>();
|
|
int index = i;
|
|
target.Changing += delegate(object sender, JsonValueChangeEventArgs e)
|
|
{
|
|
actualChangingEvents[index].Add(new Tuple<bool, JsonValue, JsonValueChangeEventArgs>(true, sender as JsonValue, e));
|
|
};
|
|
}
|
|
|
|
for (int i = 0; i < changedListeners; i++)
|
|
{
|
|
actualChangedEvents[i] = new List<Tuple<bool, JsonValue, JsonValueChangeEventArgs>>();
|
|
int index = i;
|
|
target.Changed += delegate(object sender, JsonValueChangeEventArgs e)
|
|
{
|
|
actualChangedEvents[index].Add(new Tuple<bool, JsonValue, JsonValueChangeEventArgs>(false, sender as JsonValue, e));
|
|
};
|
|
}
|
|
|
|
actionToTriggerEvents(target);
|
|
|
|
for (int i = 0; i < changingListeners; i++)
|
|
{
|
|
Console.WriteLine("Validating Changing events for listener {0}", i);
|
|
ValidateExpectedEvents(expectedChangingEvents, actualChangingEvents[i]);
|
|
}
|
|
|
|
for (int i = 0; i < changedListeners; i++)
|
|
{
|
|
Console.WriteLine("Validating Changed events for listener {0}", i);
|
|
ValidateExpectedEvents(expectedChangedEvents, actualChangedEvents[i]);
|
|
}
|
|
}
|
|
|
|
private static void ValidateJsonArrayItems(JsonArray jsonArray, IEnumerable<JsonValue> expectedItems)
|
|
{
|
|
List<JsonValue> expected = new List<JsonValue>(expectedItems);
|
|
Assert.Equal(expected.Count, jsonArray.Count);
|
|
for (int i = 0; i < expected.Count; i++)
|
|
{
|
|
Assert.Equal(expected[i], jsonArray[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|