You've already forked linux-packaging-mono
acceptance-tests
data
debian
docs
eglib
external
Lucene.Net.Light
Newtonsoft.Json
android-libunwind
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
Common
Properties
JObjectFunctionalTest.cs
JsonPrimitiveTests.cs
JsonStringRoundTripTests.cs
JsonValueAndComplexTypesTests.cs
JsonValueDynamicTests.cs
JsonValueEventsTests.cs
JsonValueLinqExtensionsIntegrationTest.cs
JsonValuePartialTrustTests.cs
JsonValueTestHelper.cs
JsonValueTests.cs
JsonValueUsageTest.cs
System.Json.Test.Integration.csproj
packages.config
System.Json.Test.Unit
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
buildtools
cecil
debian-snapshot
ikdasm
ikvm
nuget-buildtasks
nunit-lite
rx
ikvm-native
libgc
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
992 lines
41 KiB
C#
992 lines
41 KiB
C#
// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
|
|
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using Xunit;
|
|
using Assert = Microsoft.TestCommon.AssertEx;
|
|
|
|
namespace System.Json
|
|
{
|
|
/// <summary>
|
|
/// Functional tests for the JsonObject class.
|
|
/// </summary>
|
|
public class JObjectFunctionalTest
|
|
{
|
|
static int iterationCount = 500;
|
|
static int arrayLength = 10;
|
|
|
|
/// <summary>
|
|
/// Validates round-trip of a JsonArray containing both primitives and objects.
|
|
/// </summary>
|
|
[Fact]
|
|
public void MixedJsonTypeFunctionalTest()
|
|
{
|
|
bool oldValue = CreatorSettings.CreateDateTimeWithSubMilliseconds;
|
|
CreatorSettings.CreateDateTimeWithSubMilliseconds = false;
|
|
try
|
|
{
|
|
int seed = 1;
|
|
|
|
for (int i = 0; i < iterationCount; i++)
|
|
{
|
|
seed++;
|
|
Log.Info("Seed: {0}", seed);
|
|
Random rndGen = new Random(seed);
|
|
|
|
JsonArray sourceJson = new JsonArray(new List<JsonValue>()
|
|
{
|
|
PrimitiveCreator.CreateInstanceOfBoolean(rndGen),
|
|
PrimitiveCreator.CreateInstanceOfByte(rndGen),
|
|
PrimitiveCreator.CreateInstanceOfDateTime(rndGen),
|
|
PrimitiveCreator.CreateInstanceOfDateTimeOffset(rndGen),
|
|
PrimitiveCreator.CreateInstanceOfDecimal(rndGen),
|
|
PrimitiveCreator.CreateInstanceOfDouble(rndGen),
|
|
PrimitiveCreator.CreateInstanceOfInt16(rndGen),
|
|
PrimitiveCreator.CreateInstanceOfInt32(rndGen),
|
|
PrimitiveCreator.CreateInstanceOfInt64(rndGen),
|
|
PrimitiveCreator.CreateInstanceOfSByte(rndGen),
|
|
PrimitiveCreator.CreateInstanceOfSingle(rndGen),
|
|
PrimitiveCreator.CreateInstanceOfString(rndGen),
|
|
PrimitiveCreator.CreateInstanceOfUInt16(rndGen),
|
|
PrimitiveCreator.CreateInstanceOfUInt32(rndGen),
|
|
PrimitiveCreator.CreateInstanceOfUInt64(rndGen),
|
|
new JsonObject(new Dictionary<string, JsonValue>()
|
|
{
|
|
{ "Boolean", PrimitiveCreator.CreateInstanceOfBoolean(rndGen) },
|
|
{ "Byte", PrimitiveCreator.CreateInstanceOfByte(rndGen) },
|
|
{ "DateTime", PrimitiveCreator.CreateInstanceOfDateTime(rndGen) },
|
|
{ "DateTimeOffset", PrimitiveCreator.CreateInstanceOfDateTimeOffset(rndGen) },
|
|
{ "Decimal", PrimitiveCreator.CreateInstanceOfDecimal(rndGen) },
|
|
{ "Double", PrimitiveCreator.CreateInstanceOfDouble(rndGen) },
|
|
{ "Int16", PrimitiveCreator.CreateInstanceOfInt16(rndGen) },
|
|
{ "Int32", PrimitiveCreator.CreateInstanceOfInt32(rndGen) },
|
|
{ "Int64", PrimitiveCreator.CreateInstanceOfInt64(rndGen) },
|
|
{ "SByte", PrimitiveCreator.CreateInstanceOfSByte(rndGen) },
|
|
{ "Single", PrimitiveCreator.CreateInstanceOfSingle(rndGen) },
|
|
{ "String", PrimitiveCreator.CreateInstanceOfString(rndGen) },
|
|
{ "UInt16", PrimitiveCreator.CreateInstanceOfUInt16(rndGen) },
|
|
{ "UInt32", PrimitiveCreator.CreateInstanceOfUInt32(rndGen) },
|
|
{ "UInt64", PrimitiveCreator.CreateInstanceOfUInt64(rndGen) }
|
|
})
|
|
});
|
|
|
|
JsonArray newJson = (JsonArray)JsonValue.Parse(sourceJson.ToString());
|
|
Assert.True(JsonValueVerifier.Compare(sourceJson, newJson));
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
CreatorSettings.CreateDateTimeWithSubMilliseconds = oldValue;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tests for the <see cref="System.Json.JsonArray.CopyTo"/> method.
|
|
/// </summary>
|
|
[Fact]
|
|
public void JsonArrayCopytoFunctionalTest()
|
|
{
|
|
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 sourceJson = SpecialJsonValueHelper.CreatePrePopulatedJsonArray(seed, arrayLength);
|
|
JsonValue[] destJson = new JsonValue[arrayLength];
|
|
sourceJson.CopyTo(destJson, 0);
|
|
|
|
for (int k = 0; k < destJson.Length; k++)
|
|
{
|
|
if (destJson[k] != sourceJson[k])
|
|
{
|
|
retValue = false;
|
|
}
|
|
}
|
|
|
|
Assert.True(retValue, "[JsonArrayCopytoFunctionalTest] JsonArray.CopyTo() failed to function properly. destJson.GetLength(0) = " + destJson.GetLength(0));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tests for add and remove methods in the <see cref="System.Json.JsonArray"/> class.
|
|
/// </summary>
|
|
[Fact]
|
|
public void JsonArrayAddRemoveFunctionalTest()
|
|
{
|
|
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 sourceJson = SpecialJsonValueHelper.CreatePrePopulatedJsonArray(seed, arrayLength);
|
|
JsonValue[] cloneJson = SpecialJsonValueHelper.CreatePrePopulatedJsonValueArray(seed, 3);
|
|
|
|
// JsonArray.AddRange(JsonValue[])
|
|
sourceJson.AddRange(cloneJson);
|
|
if (sourceJson.Count != arrayLength + cloneJson.Length)
|
|
{
|
|
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.AddRange(JsonValue[]) failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.AddRange(JsonValue[]) passed test.");
|
|
}
|
|
|
|
// JsonArray.RemoveAt(int)
|
|
int count = sourceJson.Count;
|
|
for (int j = 0; j < count; j++)
|
|
{
|
|
sourceJson.RemoveAt(0);
|
|
}
|
|
|
|
if (sourceJson.Count > 0)
|
|
{
|
|
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.RemoveAt(int) failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.RemoveAt(int) passed test.");
|
|
}
|
|
|
|
// JsonArray.JsonType
|
|
if (sourceJson.JsonType != JsonType.Array)
|
|
{
|
|
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.JsonType failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
|
|
// JsonArray.Clear()
|
|
sourceJson = SpecialJsonValueHelper.CreatePrePopulatedJsonArray(seed, arrayLength);
|
|
sourceJson.Clear();
|
|
if (sourceJson.Count > 0)
|
|
{
|
|
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.Clear() failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.Clear() passed test.");
|
|
}
|
|
|
|
// JsonArray.AddRange(JsonValue)
|
|
sourceJson = SpecialJsonValueHelper.CreatePrePopulatedJsonArray(seed, arrayLength);
|
|
|
|
// adding one additional value to the array
|
|
sourceJson.AddRange(SpecialJsonValueHelper.GetRandomJsonPrimitives(seed));
|
|
if (sourceJson.Count != arrayLength + 1)
|
|
{
|
|
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.AddRange(JsonValue) failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.AddRange(JsonValue) passed test.");
|
|
}
|
|
|
|
// JsonArray.AddRange(IEnumerable<JsonValue> items)
|
|
sourceJson = SpecialJsonValueHelper.CreatePrePopulatedJsonArray(seed, arrayLength);
|
|
MyJsonValueCollection<JsonValue> myCols = new MyJsonValueCollection<JsonValue>();
|
|
myCols.Add(new JsonPrimitive(PrimitiveCreator.CreateInstanceOfUInt32(rndGen)));
|
|
string str;
|
|
do
|
|
{
|
|
str = PrimitiveCreator.CreateInstanceOfString(rndGen);
|
|
} while (str == null);
|
|
|
|
myCols.Add(new JsonPrimitive(str));
|
|
myCols.Add(new JsonPrimitive(PrimitiveCreator.CreateInstanceOfDateTime(rndGen)));
|
|
|
|
// adding 3 additional value to the array
|
|
sourceJson.AddRange(myCols);
|
|
if (sourceJson.Count != arrayLength + 3)
|
|
{
|
|
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.AddRange(IEnumerable<JsonValue> items) failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.AddRange(IEnumerable<JsonValue> items) passed test.");
|
|
}
|
|
|
|
// JsonArray[index].set_Item
|
|
sourceJson = SpecialJsonValueHelper.CreatePrePopulatedJsonArray(seed, arrayLength);
|
|
string temp;
|
|
do
|
|
{
|
|
temp = PrimitiveCreator.CreateInstanceOfString(rndGen);
|
|
} while (temp == null);
|
|
|
|
sourceJson[1] = temp;
|
|
if ((string)sourceJson[1] != temp)
|
|
{
|
|
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray[index].set_Item failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray[index].set_Item passed test.");
|
|
}
|
|
|
|
// JsonArray.Remove(JsonValue)
|
|
count = sourceJson.Count;
|
|
for (int j = 0; j < count; j++)
|
|
{
|
|
sourceJson.Remove(sourceJson[0]);
|
|
}
|
|
|
|
if (sourceJson.Count > 0)
|
|
{
|
|
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.Remove(JsonValue) failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
|
|
Assert.True(retValue);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tests for indexers in the <see cref="System.Json.JsonArray"/> class.
|
|
/// </summary>
|
|
[Fact]
|
|
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);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tests for the CopyTo methods in the <see cref="System.Json.JsonObject"/> class.
|
|
/// </summary>
|
|
[Fact]
|
|
public void JsonObjectCopytoFunctionalTest()
|
|
{
|
|
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;
|
|
|
|
JsonObject sourceJson = SpecialJsonValueHelper.CreateIndexPopulatedJsonObject(seed, arrayLength);
|
|
KeyValuePair<string, JsonValue>[] destJson = new KeyValuePair<string, JsonValue>[arrayLength];
|
|
if (sourceJson != null && destJson != null)
|
|
{
|
|
sourceJson.CopyTo(destJson, 0);
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonObjectCopytoFunctionalTest] sourceJson.ToString() = " + sourceJson.ToString());
|
|
Log.Info("[JsonObjectCopytoFunctionalTest] destJson.ToString() = " + destJson.ToString());
|
|
Assert.False(true, "[JsonObjectCopytoFunctionalTest] failed to create the source JsonObject object.");
|
|
return;
|
|
}
|
|
|
|
if (destJson.Length == arrayLength)
|
|
{
|
|
for (int k = 0; k < destJson.Length; k++)
|
|
{
|
|
JsonValue temp;
|
|
sourceJson.TryGetValue(k.ToString(), out temp);
|
|
if (!(temp != null && destJson[k].Value == temp))
|
|
{
|
|
retValue = false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
retValue = false;
|
|
}
|
|
|
|
Assert.True(retValue, "[JsonObjectCopytoFunctionalTest] JsonObject.CopyTo() failed to function properly. destJson.GetLength(0) = " + destJson.GetLength(0));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tests for the add and remove methods in the <see cref="System.Json.JsonObject"/> class.
|
|
/// </summary>
|
|
[Fact]
|
|
public void JsonObjectAddRemoveFunctionalTest()
|
|
{
|
|
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;
|
|
|
|
JsonObject sourceJson = SpecialJsonValueHelper.CreateIndexPopulatedJsonObject(seed, arrayLength);
|
|
|
|
// JsonObject.JsonType
|
|
if (sourceJson.JsonType != JsonType.Object)
|
|
{
|
|
Log.Info("[JsonObjectAddRemoveFunctionalTest] JsonArray.JsonType failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
|
|
// JsonObject.Add(KeyValuePair<string, JsonValue> item)
|
|
// JsonObject.Add(string key, JsonValue value)
|
|
// + various numers below so .AddRange() won't try to add an already existing value
|
|
sourceJson.Add(SpecialJsonValueHelper.GetUniqueNonNullInstanceOfString(seed + 3, sourceJson), SpecialJsonValueHelper.GetUniqueValue(seed, sourceJson));
|
|
KeyValuePair<string, JsonValue> kvp;
|
|
int startingSeed = seed + 1;
|
|
do
|
|
{
|
|
kvp = SpecialJsonValueHelper.CreatePrePopulatedKeyValuePair(startingSeed);
|
|
startingSeed++;
|
|
}
|
|
while (sourceJson.ContainsKey(kvp.Key));
|
|
|
|
sourceJson.Add(kvp);
|
|
do
|
|
{
|
|
kvp = SpecialJsonValueHelper.CreatePrePopulatedKeyValuePair(startingSeed);
|
|
startingSeed++;
|
|
}
|
|
while (sourceJson.ContainsKey(kvp.Key));
|
|
|
|
sourceJson.Add(kvp);
|
|
if (sourceJson.Count != arrayLength + 3)
|
|
{
|
|
Log.Info("[JsonObjectAddRemoveFunctionalTest] JsonObject.Add() failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonObjectAddRemoveFunctionalTest] JsonObject.Add() passed test.");
|
|
}
|
|
|
|
// JsonObject.Clear()
|
|
sourceJson.Clear();
|
|
if (sourceJson.Count > 0)
|
|
{
|
|
Log.Info("[JsonObjectAddRemoveFunctionalTest] JsonObject.Clear() failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonObjectAddRemoveFunctionalTest] JsonObject.Clear() passed test.");
|
|
}
|
|
|
|
// JsonObject.AddRange(IEnumerable<KeyValuePair<string, JsonValue>> items)
|
|
sourceJson = SpecialJsonValueHelper.CreateIndexPopulatedJsonObject(seed, arrayLength);
|
|
|
|
// + various numers below so .AddRange() won't try to add an already existing value
|
|
sourceJson.AddRange(SpecialJsonValueHelper.CreatePrePopulatedListofKeyValuePair(seed + 13 + (arrayLength * 2), 5));
|
|
if (sourceJson.Count != arrayLength + 5)
|
|
{
|
|
Log.Info("[JsonObjectAddRemoveFunctionalTest] JsonObject.AddRange(IEnumerable<KeyValuePair<string, JsonValue>> items) failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonObjectAddRemoveFunctionalTest] JsonObject.AddRange(IEnumerable<KeyValuePair<string, JsonValue>> items) passed test.");
|
|
}
|
|
|
|
// JsonObject.AddRange(params KeyValuePair<string, JsonValue>[] items)
|
|
sourceJson = SpecialJsonValueHelper.CreateIndexPopulatedJsonObject(seed, arrayLength);
|
|
|
|
// + various numers below so .AddRange() won't try to add an already existing value
|
|
KeyValuePair<string, JsonValue> item1 = SpecialJsonValueHelper.CreatePrePopulatedKeyValuePair(seed + arrayLength + 41);
|
|
KeyValuePair<string, JsonValue> item2 = SpecialJsonValueHelper.CreatePrePopulatedKeyValuePair(seed + arrayLength + 47);
|
|
KeyValuePair<string, JsonValue> item3 = SpecialJsonValueHelper.CreatePrePopulatedKeyValuePair(seed + arrayLength + 53);
|
|
sourceJson.AddRange(new KeyValuePair<string, JsonValue>[] { item1, item2, item3 });
|
|
if (sourceJson.Count != arrayLength + 3)
|
|
{
|
|
Log.Info("[JsonObjectAddRemoveFunctionalTest] JsonObject.AddRange(params KeyValuePair<string, JsonValue>[] items) failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonObjectAddRemoveFunctionalTest] JsonObject.AddRange(params KeyValuePair<string, JsonValue>[] items) passed test.");
|
|
}
|
|
|
|
sourceJson.Clear();
|
|
|
|
// JsonObject.Remove(Key)
|
|
sourceJson = SpecialJsonValueHelper.CreateIndexPopulatedJsonObject(seed, arrayLength);
|
|
int count = sourceJson.Count;
|
|
List<string> keys = new List<string>(sourceJson.Keys);
|
|
foreach (string key in keys)
|
|
{
|
|
sourceJson.Remove(key);
|
|
}
|
|
|
|
if (sourceJson.Count > 0)
|
|
{
|
|
Log.Info("[JsonObjectAddRemoveFunctionalTest] JsonObject.Remove(Key) failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonObjectAddRemoveFunctionalTest] JsonObject.Remove(Key) passed test.");
|
|
}
|
|
|
|
Assert.True(retValue);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tests for the indexers in the <see cref="System.Json.JsonObject"/> class.
|
|
/// </summary>
|
|
[Fact]
|
|
public void JsonObjectItemsFunctionalTest()
|
|
{
|
|
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;
|
|
|
|
JsonObject sourceJson = SpecialJsonValueHelper.CreateIndexPopulatedJsonObject(seed, arrayLength);
|
|
|
|
// JsonObject[key].set_Item
|
|
sourceJson["1"] = new JsonPrimitive(true);
|
|
if (sourceJson["1"].ToString() != "true")
|
|
{
|
|
Log.Info("[JsonObjectItemsFunctionalTest] JsonObject[key].set_Item failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonObjectItemsFunctionalTest] JsonObject[key].set_Item passed test.");
|
|
}
|
|
|
|
// ICollection<KeyValuePair<string, JsonValue>>.Contains(KeyValuePair<string, JsonValue> item)
|
|
KeyValuePair<string, System.Json.JsonValue> kp = new KeyValuePair<string, JsonValue>("5", sourceJson["5"]);
|
|
if (!((ICollection<KeyValuePair<string, JsonValue>>)sourceJson).Contains(kp))
|
|
{
|
|
Log.Info("[JsonObjectItemsFunctionalTest] ICollection<KeyValuePair<string, JsonValue>>.Contains(KeyValuePair<string, JsonValue> item) failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonObjectItemsFunctionalTest] ICollection<KeyValuePair<string, JsonValue>>.Contains(KeyValuePair<string, JsonValue> item) passed test.");
|
|
}
|
|
|
|
// ICollection<KeyValuePair<string, JsonValue>>.IsReadOnly
|
|
if (((ICollection<KeyValuePair<string, JsonValue>>)sourceJson).IsReadOnly)
|
|
{
|
|
Log.Info("[JsonObjectItemsFunctionalTest] ICollection<KeyValuePair<string, JsonValue>>.IsReadOnly failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonObjectItemsFunctionalTest] ICollection<KeyValuePair<string, JsonValue>>.IsReadOnly passed test.");
|
|
}
|
|
|
|
// ICollection<KeyValuePair<string, JsonValue>>.Add(KeyValuePair<string, JsonValue> item)
|
|
kp = new KeyValuePair<string, JsonValue>("100", new JsonPrimitive(100));
|
|
((ICollection<KeyValuePair<string, JsonValue>>)sourceJson).Add(kp);
|
|
if (sourceJson.Count != arrayLength + 1)
|
|
{
|
|
Log.Info("[JsonObjectItemsFunctionalTest] ICollection<KeyValuePair<string, JsonValue>>.Add(KeyValuePair<string, JsonValue> item) failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonObjectItemsFunctionalTest] ICollection<KeyValuePair<string, JsonValue>>.Add(KeyValuePair<string, JsonValue> item) passed test.");
|
|
}
|
|
|
|
// ICollection<KeyValuePair<string, JsonValue>>.Remove(KeyValuePair<string, JsonValue> item)
|
|
((ICollection<KeyValuePair<string, JsonValue>>)sourceJson).Remove(kp);
|
|
if (sourceJson.Count != arrayLength)
|
|
{
|
|
Log.Info("[JsonObjectItemsFunctionalTest] ICollection<KeyValuePair<string, JsonValue>>.Remove(KeyValuePair<string, JsonValue> item) failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonObjectItemsFunctionalTest] ICollection<KeyValuePair<string, JsonValue>>.Remove(KeyValuePair<string, JsonValue> item) passed test.");
|
|
}
|
|
|
|
// ICollection<KeyValuePair<string, JsonValue>>.GetEnumerator()
|
|
JsonObject jo = new JsonObject { { "member 1", 123 }, { "member 2", new JsonArray { 1, 2, 3 } } };
|
|
List<string> expected = new List<string> { "member 1 - 123", "member 2 - [1,2,3]" };
|
|
expected.Sort();
|
|
IEnumerator<KeyValuePair<string, JsonValue>> ko = ((ICollection<KeyValuePair<string, JsonValue>>)jo).GetEnumerator();
|
|
List<string> actual = new List<string>();
|
|
ko.Reset();
|
|
ko.MoveNext();
|
|
do
|
|
{
|
|
actual.Add(String.Format("{0} - {1}", ko.Current.Key, ko.Current.Value.ToString()));
|
|
Log.Info("added one item: {0}", String.Format("{0} - {1}", ko.Current.Key, ko.Current.Value));
|
|
ko.MoveNext();
|
|
}
|
|
while (ko.Current.Value != null);
|
|
|
|
actual.Sort();
|
|
if (!JsonValueVerifier.CompareStringLists(expected, actual))
|
|
{
|
|
Log.Info("[JsonObjectItemsFunctionalTest] ICollection<KeyValuePair<string, JsonValue>>.GetEnumerator() failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonObjectItemsFunctionalTest] ICollection<KeyValuePair<string, JsonValue>>.GetEnumerator() passed test.");
|
|
}
|
|
|
|
// JsonObject.Values
|
|
sourceJson = SpecialJsonValueHelper.CreateIndexPopulatedJsonObject(seed, arrayLength);
|
|
JsonValue[] manyValues = SpecialJsonValueHelper.CreatePrePopulatedJsonValueArray(seed, arrayLength);
|
|
JsonObject jov = new JsonObject();
|
|
for (int j = 0; j < manyValues.Length; j++)
|
|
{
|
|
jov.Add("member" + j, manyValues[j]);
|
|
}
|
|
|
|
List<string> expectedList = new List<string>();
|
|
foreach (JsonValue v in manyValues)
|
|
{
|
|
expectedList.Add(v.ToString());
|
|
}
|
|
|
|
expectedList.Sort();
|
|
List<string> actualList = new List<string>();
|
|
foreach (JsonValue v in jov.Values)
|
|
{
|
|
actualList.Add(v.ToString());
|
|
}
|
|
|
|
actualList.Sort();
|
|
if (!JsonValueVerifier.CompareStringLists(expectedList, actualList))
|
|
{
|
|
Log.Info("[JsonObjectItemsFunctionalTest] JsonObject.Values failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonObjectItemsFunctionalTest] JsonObject.Values passed test.");
|
|
}
|
|
|
|
for (int j = 0; j < sourceJson.Count; j++)
|
|
{
|
|
// JsonObject.Contains(Key)
|
|
if (!sourceJson.ContainsKey(j.ToString()))
|
|
{
|
|
Log.Info("[JsonObjectItemsFunctionalTest] JsonObject.Contains(Key) failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonObjectItemsFunctionalTest] JsonObject.Contains(Key) passed test.");
|
|
}
|
|
|
|
// JsonObject.TryGetValue(String, out JsonValue)
|
|
JsonValue retJson;
|
|
if (!sourceJson.TryGetValue(j.ToString(), out retJson))
|
|
{
|
|
Log.Info("[JsonObjectItemsFunctionalTest] JsonObject.TryGetValue(String, out JsonValue) failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else if (retJson != sourceJson[j.ToString()])
|
|
{
|
|
// JsonObjectthis[string key]
|
|
Log.Info("[JsonObjectItemsFunctionalTest] JsonObject[string key] or JsonObject.TryGetValue(String, out JsonValue) failed to function properly.");
|
|
retValue = false;
|
|
}
|
|
else
|
|
{
|
|
Log.Info("[JsonObjectItemsFunctionalTest] JsonObject.TryGetValue(String, out JsonValue) & JsonObject[string key] passed test.");
|
|
}
|
|
}
|
|
|
|
Assert.True(retValue);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tests for casting to integer values.
|
|
/// </summary>
|
|
[Fact]
|
|
public void GettingIntegerValueTest()
|
|
{
|
|
string json = "{\"byte\":160,\"sbyte\":-89,\"short\":12345,\"ushort\":65530," +
|
|
"\"int\":1234567890,\"uint\":3000000000,\"long\":1234567890123456," +
|
|
"\"ulong\":10000000000000000000}";
|
|
Dictionary<string, object> expected = new Dictionary<string, object>();
|
|
expected.Add("byte", (byte)160);
|
|
expected.Add("sbyte", (sbyte)-89);
|
|
expected.Add("short", (short)12345);
|
|
expected.Add("ushort", (ushort)65530);
|
|
expected.Add("int", (int)1234567890);
|
|
expected.Add("uint", (uint)3000000000);
|
|
expected.Add("long", (long)1234567890123456L);
|
|
expected.Add("ulong", (((ulong)5000000000000000000L) * 2));
|
|
JsonObject jo = (JsonObject)JsonValue.Parse(json);
|
|
bool success = true;
|
|
foreach (string key in jo.Keys)
|
|
{
|
|
object expectedObj = expected[key];
|
|
Log.Info("Testing for type = {0}", key);
|
|
try
|
|
{
|
|
switch (key)
|
|
{
|
|
case "byte":
|
|
Assert.Equal<byte>((byte)expectedObj, (byte)jo[key]);
|
|
break;
|
|
case "sbyte":
|
|
Assert.Equal<sbyte>((sbyte)expectedObj, (sbyte)jo[key]);
|
|
break;
|
|
case "short":
|
|
Assert.Equal<short>((short)expectedObj, (short)jo[key]);
|
|
break;
|
|
case "ushort":
|
|
Assert.Equal<ushort>((ushort)expectedObj, (ushort)jo[key]);
|
|
break;
|
|
case "int":
|
|
Assert.Equal<int>((int)expectedObj, (int)jo[key]);
|
|
break;
|
|
case "uint":
|
|
Assert.Equal<uint>((uint)expectedObj, (uint)jo[key]);
|
|
break;
|
|
case "long":
|
|
Assert.Equal<long>((long)expectedObj, (long)jo[key]);
|
|
break;
|
|
case "ulong":
|
|
Assert.Equal<ulong>((ulong)expectedObj, (ulong)jo[key]);
|
|
break;
|
|
}
|
|
}
|
|
catch (InvalidCastException e)
|
|
{
|
|
Log.Info("Caught InvalidCastException: {0}", e);
|
|
success = false;
|
|
}
|
|
}
|
|
|
|
Assert.True(success);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tests for casting to floating point values.
|
|
/// </summary>
|
|
[Fact]
|
|
public void GettingFloatingPointValueTest()
|
|
{
|
|
string json = "{\"float\":1.23,\"double\":1.23e+290,\"decimal\":1234567890.123456789}";
|
|
Dictionary<string, object> expected = new Dictionary<string, object>();
|
|
expected.Add("float", 1.23f);
|
|
expected.Add("double", 1.23e+290);
|
|
expected.Add("decimal", 1234567890.123456789m);
|
|
JsonObject jo = (JsonObject)JsonValue.Parse(json);
|
|
bool success = true;
|
|
foreach (string key in jo.Keys)
|
|
{
|
|
object expectedObj = expected[key];
|
|
Log.Info("Testing for type = {0}", key);
|
|
try
|
|
{
|
|
switch (key)
|
|
{
|
|
case "float":
|
|
Assert.Equal<float>((float)expectedObj, (float)jo[key]);
|
|
break;
|
|
case "double":
|
|
Assert.Equal<double>((double)expectedObj, (double)jo[key]);
|
|
break;
|
|
case "decimal":
|
|
Assert.Equal<decimal>((decimal)expectedObj, (decimal)jo[key]);
|
|
break;
|
|
}
|
|
}
|
|
catch (InvalidCastException e)
|
|
{
|
|
Log.Info("Caught InvalidCastException: {0}", e);
|
|
success = false;
|
|
}
|
|
}
|
|
|
|
Assert.True(success);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Negative tests for invalid operations.
|
|
/// </summary>
|
|
[Fact]
|
|
public void TestInvalidOperations()
|
|
{
|
|
JsonArray ja = new JsonArray { 1, null, "hello" };
|
|
JsonObject jo = new JsonObject
|
|
{
|
|
{ "first", 1 },
|
|
{ "second", null },
|
|
{ "third", "hello" },
|
|
};
|
|
JsonPrimitive jp = new JsonPrimitive("hello");
|
|
|
|
Assert.Throws<InvalidOperationException>(() => "jp[\"hello\"] should fail: " + jp["hello"].ToString());
|
|
|
|
Assert.Throws<InvalidOperationException>(() => "ja[\"hello\"] should fail: " + ja["hello"].ToString());
|
|
|
|
|
|
Assert.Throws<InvalidOperationException>(() => jp["hello"] = "This shouldn't happen");
|
|
|
|
|
|
Assert.Throws<InvalidOperationException>(() => ja["hello"] = "This shouldn't happen");
|
|
|
|
Assert.Throws<InvalidOperationException>(() => ("jp[1] should fail: " + jp[1].ToString()));
|
|
|
|
Assert.Throws<InvalidOperationException>(() => "jo[0] should fail: " + jo[1].ToString());
|
|
|
|
Assert.Throws<InvalidOperationException>(() => jp[0] = "This shouldn't happen");
|
|
|
|
Assert.Throws<InvalidOperationException>(() => jo[0] = "This shouldn't happen");
|
|
|
|
Assert.Throws<InvalidCastException>(() => "(DateTimeOffset)jp[\"hello\"] should fail: " + (DateTimeOffset)jp);
|
|
|
|
Assert.Throws<InvalidCastException>(() => ("(Char)jp[\"hello\"] should fail: " + (char)jp));
|
|
|
|
Assert.Throws<InvalidCastException>(() =>
|
|
{
|
|
short jprim = (short)new JsonPrimitive(false);
|
|
});
|
|
}
|
|
|
|
/// <summary>
|
|
/// Test for consuming deeply nested object graphs.
|
|
/// </summary>
|
|
[Fact]
|
|
public void TestDeeplyNestedObjectGraph()
|
|
{
|
|
JsonObject jo = new JsonObject();
|
|
JsonObject current = jo;
|
|
StringBuilder builderExpected = new StringBuilder();
|
|
builderExpected.Append('{');
|
|
int depth = 10000;
|
|
for (int i = 0; i < depth; i++)
|
|
{
|
|
JsonObject next = new JsonObject();
|
|
string key = i.ToString(CultureInfo.InvariantCulture);
|
|
builderExpected.AppendFormat("\"{0}\":{{", key);
|
|
current.Add(key, next);
|
|
current = next;
|
|
}
|
|
|
|
for (int i = 0; i < depth + 1; i++)
|
|
{
|
|
builderExpected.Append('}');
|
|
}
|
|
|
|
Assert.Equal(builderExpected.ToString(), jo.ToString());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Test for consuming deeply nested array graphs.
|
|
/// </summary>
|
|
[Fact]
|
|
public void TestDeeplyNestedArrayGraph()
|
|
{
|
|
JsonArray ja = new JsonArray();
|
|
JsonArray current = ja;
|
|
StringBuilder builderExpected = new StringBuilder();
|
|
builderExpected.Append('[');
|
|
int depth = 10000;
|
|
for (int i = 0; i < depth; i++)
|
|
{
|
|
JsonArray next = new JsonArray();
|
|
builderExpected.Append('[');
|
|
current.Add(next);
|
|
current = next;
|
|
}
|
|
|
|
for (int i = 0; i < depth + 1; i++)
|
|
{
|
|
builderExpected.Append(']');
|
|
}
|
|
|
|
Assert.Equal(builderExpected.ToString(), ja.ToString());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Test for consuming deeply nested object and array graphs.
|
|
/// </summary>
|
|
[Fact]
|
|
public void TestDeeplyNestedObjectAndArrayGraph()
|
|
{
|
|
JsonObject jo = new JsonObject();
|
|
JsonObject current = jo;
|
|
StringBuilder builderExpected = new StringBuilder();
|
|
builderExpected.Append('{');
|
|
int depth = 10000;
|
|
for (int i = 0; i < depth; i++)
|
|
{
|
|
JsonObject next = new JsonObject();
|
|
string key = i.ToString(CultureInfo.InvariantCulture);
|
|
builderExpected.AppendFormat("\"{0}\":[{{", key);
|
|
current.Add(key, new JsonArray(next));
|
|
current = next;
|
|
}
|
|
|
|
for (int i = 0; i < depth; i++)
|
|
{
|
|
builderExpected.Append("}]");
|
|
}
|
|
|
|
builderExpected.Append('}');
|
|
|
|
Assert.Equal(builderExpected.ToString(), jo.ToString());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Test for calling <see cref="JsonValue.ToString()"/> on the same instance in different threads.
|
|
/// </summary>
|
|
[Fact]
|
|
public void TestConcurrentToString()
|
|
{
|
|
bool exceptionThrown = false;
|
|
bool incorrectValue = false;
|
|
JsonObject jo = new JsonObject();
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append('{');
|
|
for (int i = 0; i < 100000; i++)
|
|
{
|
|
if (i > 0)
|
|
{
|
|
sb.Append(',');
|
|
}
|
|
|
|
string key = i.ToString(CultureInfo.InvariantCulture);
|
|
jo.Add(key, i);
|
|
sb.AppendFormat("\"{0}\":{0}", key);
|
|
}
|
|
|
|
sb.Append('}');
|
|
string expected = sb.ToString();
|
|
|
|
int numberOfThreads = 5;
|
|
Thread[] threads = new Thread[numberOfThreads];
|
|
for (int i = 0; i < numberOfThreads; i++)
|
|
{
|
|
threads[i] = new Thread(new ThreadStart(delegate
|
|
{
|
|
for (int j = 0; j < 10; j++)
|
|
{
|
|
try
|
|
{
|
|
string str = jo.ToString();
|
|
if (str != expected)
|
|
{
|
|
incorrectValue = true;
|
|
Log.Info("Value is incorrect");
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
exceptionThrown = true;
|
|
Log.Info("Exception thrown: {0}", e);
|
|
}
|
|
}
|
|
}));
|
|
}
|
|
|
|
for (int i = 0; i < numberOfThreads; i++)
|
|
{
|
|
threads[i].Start();
|
|
}
|
|
|
|
for (int i = 0; i < numberOfThreads; i++)
|
|
{
|
|
threads[i].Join();
|
|
}
|
|
|
|
Assert.False(incorrectValue);
|
|
Assert.False(exceptionThrown);
|
|
}
|
|
|
|
class MyJsonValueCollection<JsonValue> : System.Collections.Generic.IEnumerable<JsonValue>
|
|
{
|
|
List<JsonValue> internalList = new List<JsonValue>();
|
|
|
|
public MyJsonValueCollection()
|
|
{
|
|
}
|
|
|
|
public void Add(JsonValue obj)
|
|
{
|
|
this.internalList.Add(obj);
|
|
}
|
|
|
|
public IEnumerator<JsonValue> GetEnumerator()
|
|
{
|
|
return this.internalList.GetEnumerator();
|
|
}
|
|
|
|
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
|
|
{
|
|
return this.GetEnumerator();
|
|
}
|
|
}
|
|
}
|
|
} |