public static void ValidateAreSame(string expected, string actual, string description = null, bool ignoreCase = false, bool ignoreDefaultValues = false)
{
JObject expectedJson = JObject.Parse(expected);
JObject actualJson = JObject.Parse(actual);
JsonComparer.ValidateAreSame(expectedJson, actualJson, description, ignoreCase, ignoreDefaultValues);
}
public static void ValidateAreSame(JProperty expected, JProperty actual, string description = null, bool ignoreCase = false, bool ignoreDefaultValues = false)
{
if ((expected == null) != (actual == null))
{
Assert.Equal(expected, actual);
}
JsonComparer.ValidateAreSame(expected.Value, expected.Value, description, ignoreCase, ignoreDefaultValues);
}
public static void ValidateAreSame(JArray expected, JArray actual, string description = null, bool ignoreCase = false, bool ignoreDefaultValues = false)
{
if ((expected == null) != (actual == null))
{
Assert.Equal(expected, actual);
}
Assert.Equal(expected.Count, actual.Count);
for (int i = 0; i < expected.Count; i++)
{
JsonComparer.ValidateAreSame(expected[i], actual[i], description + "[" + i + "]", ignoreCase, ignoreDefaultValues);
}
}
/// <summary>
/// Asserts if the two instances are not the same.
/// </summary>
public static void ValidateAreSame(
JObject expected,
JObject actual,
string description = null,
bool ignoreCase = false,
bool ignoreDefaultValues = false)
{
if (object.ReferenceEquals(expected, actual))
{
// if the two instances are the same, no need to do further validation.
return;
}
// If only one is null, fail.
if ((expected == null) != (actual == null))
{
Assert.Equal(expected, actual);
return;
}
var expectedKeys = new HashSet <string>(((IDictionary <string, JToken>)expected).Keys);
var actualKeys = new HashSet <string>(((IDictionary <string, JToken>)actual).Keys);
List <string> missingKeys = expectedKeys.Except(actualKeys, JsonUtilities.PropertyNameComparer).ToList();
List <string> unexpectedKeys = actualKeys.Except(expectedKeys, JsonUtilities.PropertyNameComparer).ToList();
JsonComparer.HandleKeyDiscrepancies(missingKeys, expected, ignoreDefaultValues, "{0} is missing the following key(s): {1}", description);
JsonComparer.HandleKeyDiscrepancies(unexpectedKeys, actual, ignoreDefaultValues, "{0} contains the following unexpected key(s): {1}", description);
var commonKeys = new HashSet <string>(expectedKeys.Intersect(actualKeys, JsonUtilities.PropertyNameComparer));
foreach (KeyValuePair <string, JToken> pair in expected)
{
string key = pair.Key;
if (!commonKeys.Contains(key))
{
continue;
}
//JToken expectedValue = pair.Value;
JToken expectedValue = expected.GetValue(key, JsonUtilities.PropertyNameComparison);
JToken actualValue = actual.GetValue(key, JsonUtilities.PropertyNameComparison);
JsonComparer.ValidateAreSame(expectedValue, actualValue, description + "." + key, ignoreCase, ignoreDefaultValues);
}
}
public static void AssertAreEqual(Object expected, Object actual)
{
string jsonExpected = JsonConvert.SerializeObject(expected);
string jsonActual = JsonConvert.SerializeObject(actual);
string description = null;
if (expected != null)
{
description = expected.GetType().Name;
}
JsonComparer.ValidateAreSame(
JObject.Parse(jsonExpected),
JObject.Parse(jsonActual),
description,
ignoreCase: true,
ignoreDefaultValues: true);
}
public static void ValidateAreSame(JToken expected, JToken actual, string description = null, bool ignoreCase = false, bool ignoreDefaultValues = false)
{
if (JsonComparer.IsDefaultValue(expected) && JsonComparer.IsDefaultValue(actual))
{
return;
}
if ((expected == null) != (actual == null))
{
Assert.Equal(expected, actual);
}
Action validateTypesAreEqual = () =>
{
Assert.Equal(expected.Type, actual.Type);
};
switch (expected.Type)
{
case JTokenType.Object:
validateTypesAreEqual();
JsonComparer.ValidateAreSame((JObject)expected, (JObject)actual, description, ignoreCase, ignoreDefaultValues);
break;
case JTokenType.Array:
validateTypesAreEqual();
JsonComparer.ValidateAreSame((JArray)expected, (JArray)actual, description, ignoreCase, ignoreDefaultValues);
break;
case JTokenType.Boolean:
case JTokenType.Bytes:
case JTokenType.Comment:
case JTokenType.Date:
case JTokenType.Float:
case JTokenType.Guid:
case JTokenType.Integer:
case JTokenType.Raw:
case JTokenType.String:
case JTokenType.TimeSpan:
case JTokenType.Uri:
if (!(actual is JValue))
{
validateTypesAreEqual();
}
JsonComparer.ValidateAreSame((JValue)expected, (JValue)actual, description, ignoreCase);
break;
case JTokenType.Property:
validateTypesAreEqual();
JsonComparer.ValidateAreSame((JProperty)expected, (JProperty)actual, description, ignoreCase, ignoreDefaultValues);
break;
case JTokenType.Null:
validateTypesAreEqual();
break;
case JTokenType.Constructor:
case JTokenType.None:
case JTokenType.Undefined:
default:
throw new NotImplementedException("Validation logic not implemented for JTokenType " + expected.Type);
}
}
