private static void AssertJsonEqual(JsonElement expected, JsonElement actual)
{
JsonValueKind valueKind = expected.ValueKind;
Assert.Equal(valueKind, actual.ValueKind);
switch (valueKind)
{
case JsonValueKind.Object:
var propertyNames = new HashSet <string>();
foreach (JsonProperty property in expected.EnumerateObject())
{
propertyNames.Add(property.Name);
}
foreach (JsonProperty property in actual.EnumerateObject())
{
propertyNames.Add(property.Name);
}
foreach (string name in propertyNames)
{
AssertJsonEqual(expected.GetProperty(name), actual.GetProperty(name));
}
break;
case JsonValueKind.Array:
JsonElement.ArrayEnumerator expectedEnumerator = actual.EnumerateArray();
JsonElement.ArrayEnumerator actualEnumerator = expected.EnumerateArray();
while (expectedEnumerator.MoveNext())
{
Assert.True(actualEnumerator.MoveNext());
AssertJsonEqual(expectedEnumerator.Current, actualEnumerator.Current);
}
Assert.False(actualEnumerator.MoveNext());
break;
case JsonValueKind.String:
Assert.Equal(expected.GetString(), actual.GetString());
break;
case JsonValueKind.Number:
Assert.Equal(expected.GetRawText(), actual.GetRawText());
break;
default:
throw new NotImplementedException();
}
}
internal JsonList(JSONELEMENT element)
{
if (element.ValueKind != JsonValueKind.Array)
{
throw new ArgumentException("Must be JsonValueKind.Array", nameof(element));
}
foreach (var item in element.EnumerateArray())
{
var xitem = JsonValue.DeepClone(item);
this.Add(xitem);
}
}
public static _JsonArray CreateFrom(JSONELEMENT array)
{
if (array.ValueKind != JsonValueKind.Array)
{
throw new ArgumentException("Must be JsonValueKind.Array", nameof(array));
}
Object convert(JsonElement element)
{
return(_JsonStaticUtils.Deserialize(element));
}
using (var entries = array.EnumerateArray())
{
return(_From(entries.Select(convert)));
}
}
/// <summary>
/// Performs a deep copy operation on <paramref name="jsonElement"/> returning corresponding modifiable tree structure of JSON nodes.
/// Operations performed on returned <see cref="JsonNode"/> does not modify <paramref name="jsonElement"/>.
/// </summary>
/// <param name="jsonElement"><see cref="JsonElement"/> to copy.</param>
/// <returns><see cref="JsonNode"/> representing <paramref name="jsonElement"/>.</returns>
public static JsonNode DeepCopy(JsonElement jsonElement)
{
if (!jsonElement.IsImmutable)
{
return(GetNode(jsonElement).Clone());
}
switch (jsonElement.ValueKind)
{
case JsonValueKind.Object:
JsonObject jsonObject = new JsonObject();
foreach (JsonProperty property in jsonElement.EnumerateObject())
{
jsonObject.Add(property.Name, DeepCopy(property.Value));
}
return(jsonObject);
case JsonValueKind.Array:
JsonArray jsonArray = new JsonArray();
foreach (JsonElement element in jsonElement.EnumerateArray())
{
jsonArray.Add(DeepCopy(element));
}
return(jsonArray);
case JsonValueKind.Number:
return(new JsonNumber(jsonElement.GetRawText()));
case JsonValueKind.String:
return(new JsonString(jsonElement.GetString()));
case JsonValueKind.True:
return(new JsonBoolean(true));
case JsonValueKind.False:
return(new JsonBoolean(false));
case JsonValueKind.Null:
return(null);
default:
Debug.Assert(jsonElement.ValueKind == JsonValueKind.Undefined, "No handler for JsonValueKind.{jsonElement.ValueKind}");
throw ThrowHelper.GetJsonElementWrongTypeException(JsonValueKind.Undefined, jsonElement.ValueKind);
}
}
public static TabularDataResource ToTabularDataResource(this JsonElement jsonElement)
{
if (jsonElement.ValueKind != JsonValueKind.Array)
{
throw new InvalidOperationException("input must be a valid array of object");
}
var collection = new List <object>();
foreach (var element in jsonElement.EnumerateArray())
{
var dataObject = JsonSerializer.Deserialize <Dictionary <string, object> >(element.GetRawText(),
TabularDataResourceFormatter.JsonSerializerOptions);
collection.Add(dataObject);
}
return(collection.ToTabularDataResource());
}
public static IEnumerable <JsonElement> ChildrenTokens(this JsonElement src)
{
if (src.ValueKind == JsonValueKind.Object)
{
foreach (var item in src.EnumerateObject())
{
yield return(item.Value);
}
}
if (src.ValueKind == JsonValueKind.Array)
{
foreach (var item in src.EnumerateArray())
{
yield return(item);
}
}
}
internal static IEnumerable <JsonProperty> ChildrenPropertiesCore(this JsonElement src)
{
if (src.ValueKind == JsonValueKind.Object)
{
foreach (var item in src.EnumerateObject())
{
yield return(item);
}
}
if (src.ValueKind == JsonValueKind.Array)
{
foreach (var item in src.EnumerateArray())
{
foreach (JsonProperty o in item.ChildrenPropertiesCore())
{
yield return(o);
}
}
}
}
private static void AssertJsonEqualCore(JsonElement expected, JsonElement actual, Stack <object> path)
{
JsonValueKind valueKind = expected.ValueKind;
AssertTrue(passCondition: valueKind == actual.ValueKind);
switch (valueKind)
{
case JsonValueKind.Object:
var expectedProperties = new List <string>();
foreach (JsonProperty property in expected.EnumerateObject())
{
expectedProperties.Add(property.Name);
}
var actualProperties = new List <string>();
foreach (JsonProperty property in actual.EnumerateObject())
{
actualProperties.Add(property.Name);
}
foreach (var property in expectedProperties.Except(actualProperties))
{
AssertTrue(passCondition: false, $"Property \"{property}\" missing from actual object.");
}
foreach (var property in actualProperties.Except(expectedProperties))
{
AssertTrue(passCondition: false, $"Actual object defines additional property \"{property}\".");
}
foreach (string name in expectedProperties)
{
path.Push(name);
AssertJsonEqualCore(expected.GetProperty(name), actual.GetProperty(name), path);
path.Pop();
}
break;
case JsonValueKind.Array:
JsonElement.ArrayEnumerator expectedEnumerator = expected.EnumerateArray();
JsonElement.ArrayEnumerator actualEnumerator = actual.EnumerateArray();
int i = 0;
while (expectedEnumerator.MoveNext())
{
AssertTrue(passCondition: actualEnumerator.MoveNext(), "Actual array contains fewer elements.");
path.Push(i++);
AssertJsonEqualCore(expectedEnumerator.Current, actualEnumerator.Current, path);
path.Pop();
}
AssertTrue(passCondition: !actualEnumerator.MoveNext(), "Actual array contains additional elements.");
break;
case JsonValueKind.String:
AssertTrue(passCondition: expected.GetString() == actual.GetString());
break;
case JsonValueKind.Number:
case JsonValueKind.True:
case JsonValueKind.False:
case JsonValueKind.Null:
AssertTrue(passCondition: expected.GetRawText() == actual.GetRawText());
break;
default:
Debug.Fail($"Unexpected JsonValueKind: JsonValueKind.{valueKind}.");
break;
}
void AssertTrue(bool passCondition, string?message = null)
{
if (!passCondition)
{
message ??= "Expected JSON does not match actual value";
Assert.Fail($"{message}\nExpected JSON: {expected}\n Actual JSON: {actual}\n in JsonPath: {BuildJsonPath(path)}");
}