1111 lines
49 KiB
C#
1111 lines
49 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.Dynamic;
|
|||
|
|
using System.Globalization;
|
|||
|
|
using System.Reflection;
|
|||
|
|
using System.Runtime.Serialization.Json;
|
|||
|
|
using Xunit;
|
|||
|
|
|
|||
|
|
namespace System.Json
|
|||
|
|
{
|
|||
|
|
/// <summary>
|
|||
|
|
/// Tests for the dynamic support for <see cref="JsonValue"/>.
|
|||
|
|
/// </summary>
|
|||
|
|
public class JsonValueDynamicTests
|
|||
|
|
{
|
|||
|
|
string teamNameValue = "WCF RIA Base";
|
|||
|
|
string[] teamMembersValues = { "Carlos", "Chris", "Joe", "Miguel", "Yavor" };
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Tests for the dynamic getters in <see cref="JsonObject"/> instances.
|
|||
|
|
/// </summary>
|
|||
|
|
[Fact]
|
|||
|
|
public void JsonObjectDynamicGetters()
|
|||
|
|
{
|
|||
|
|
dynamic team = new JsonObject();
|
|||
|
|
team["TeamSize"] = this.teamMembersValues.Length;
|
|||
|
|
team["TeamName"] = this.teamNameValue;
|
|||
|
|
team["TeamMascots"] = null;
|
|||
|
|
team["TeamMembers"] = new JsonArray
|
|||
|
|
{
|
|||
|
|
this.teamMembersValues[0], this.teamMembersValues[1], this.teamMembersValues[2],
|
|||
|
|
this.teamMembersValues[3], this.teamMembersValues[4]
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Assert.Equal(this.teamMembersValues.Length, (int)team.TeamSize);
|
|||
|
|
Assert.Equal(this.teamNameValue, (string)team.TeamName);
|
|||
|
|
Assert.NotNull(team.TeamMascots);
|
|||
|
|
Assert.True(team.TeamMascots is JsonValue); // default
|
|||
|
|
|
|||
|
|
for (int i = 0; i < this.teamMembersValues.Length; i++)
|
|||
|
|
{
|
|||
|
|
Assert.Equal(this.teamMembersValues[i], (string)team.TeamMembers[i]);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
for (int i = 0; i < this.teamMembersValues.Length; i++)
|
|||
|
|
{
|
|||
|
|
Assert.Equal(this.teamMembersValues[i], (string)team.TeamMembers[i]);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Negative tests for getters
|
|||
|
|
JsonValueTests.ExpectException<InvalidCastException>(delegate { int fail = (int)team.NonExistentProp; });
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Tests for the dynamic setters in <see cref="JsonObject"/> instances.
|
|||
|
|
/// </summary>
|
|||
|
|
[Fact]
|
|||
|
|
public void JsonObjectDynamicSetters()
|
|||
|
|
{
|
|||
|
|
dynamic team = new JsonObject();
|
|||
|
|
team.TeamSize = this.teamMembersValues.Length;
|
|||
|
|
team.TeamName = this.teamNameValue;
|
|||
|
|
team.TeamMascots = null;
|
|||
|
|
team.TeamMembers = new JsonArray
|
|||
|
|
{
|
|||
|
|
this.teamMembersValues[0], this.teamMembersValues[1], this.teamMembersValues[2],
|
|||
|
|
this.teamMembersValues[3], this.teamMembersValues[4]
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Assert.Equal(this.teamMembersValues.Length, (int)team["TeamSize"]);
|
|||
|
|
Assert.Equal(this.teamNameValue, (string)team["TeamName"]);
|
|||
|
|
Assert.NotNull(team["TeamMascots"]);
|
|||
|
|
Assert.True(team["TeamMascots"] is JsonValue);
|
|||
|
|
|
|||
|
|
for (int i = 0; i < this.teamMembersValues.Length; i++)
|
|||
|
|
{
|
|||
|
|
Assert.Equal(this.teamMembersValues[i], (string)team["TeamMembers"][i]);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Could not come up with negative setter
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Tests for the dynamic indexers in <see cref="JsonArray"/> instances.
|
|||
|
|
/// </summary>
|
|||
|
|
[Fact]
|
|||
|
|
public void JsonArrayDynamicSanity()
|
|||
|
|
{
|
|||
|
|
// Sanity test for JsonArray to ensure [] still works even if dynamic
|
|||
|
|
dynamic people = new JsonArray();
|
|||
|
|
foreach (string member in this.teamMembersValues)
|
|||
|
|
{
|
|||
|
|
people.Add(member);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Assert.Equal(this.teamMembersValues[0], (string)people[0]);
|
|||
|
|
Assert.Equal(this.teamMembersValues[1], (string)people[1]);
|
|||
|
|
Assert.Equal(this.teamMembersValues[2], (string)people[2]);
|
|||
|
|
Assert.Equal(this.teamMembersValues[3], (string)people[3]);
|
|||
|
|
Assert.Equal(this.teamMembersValues[4], (string)people[4]);
|
|||
|
|
|
|||
|
|
// Note: this test and the above execute the dynamic binder differently.
|
|||
|
|
for (int i = 0; i < people.Count; i++)
|
|||
|
|
{
|
|||
|
|
Assert.Equal(this.teamMembersValues[i], (string)people[i]);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
people.Add(this.teamMembersValues.Length);
|
|||
|
|
people.Add(this.teamNameValue);
|
|||
|
|
|
|||
|
|
Assert.Equal(this.teamMembersValues.Length, (int)people[5]);
|
|||
|
|
Assert.Equal(this.teamNameValue, (string)people[6]);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Tests for calling methods in dynamic references to <see cref="JsonValue"/> instances.
|
|||
|
|
/// </summary>
|
|||
|
|
[Fact]
|
|||
|
|
public void DynamicMethodCalling()
|
|||
|
|
{
|
|||
|
|
JsonObject jo = new JsonObject();
|
|||
|
|
dynamic dyn = jo;
|
|||
|
|
dyn.Foo = "bar";
|
|||
|
|
Assert.Equal(1, jo.Count);
|
|||
|
|
Assert.Equal(1, dyn.Count);
|
|||
|
|
dyn.Remove("Foo");
|
|||
|
|
Assert.Equal(0, jo.Count);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Tests for using boolean operators in dynamic references to <see cref="JsonValue"/> instances.
|
|||
|
|
/// </summary>
|
|||
|
|
[Fact(Skip = "Ignore")]
|
|||
|
|
public void DynamicBooleanOperators()
|
|||
|
|
{
|
|||
|
|
JsonValue jv;
|
|||
|
|
dynamic dyn;
|
|||
|
|
foreach (bool value in new bool[] { true, false })
|
|||
|
|
{
|
|||
|
|
jv = value;
|
|||
|
|
dyn = jv;
|
|||
|
|
Log.Info("IsTrue, {0}", jv);
|
|||
|
|
if (dyn)
|
|||
|
|
{
|
|||
|
|
Assert.True(value, "Boolean evaluation should not enter 'if' clause.");
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
Assert.False(value, "Boolean evaluation should not enter 'else' clause.");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
foreach (string value in new string[] { "true", "false", "True", "False" })
|
|||
|
|
{
|
|||
|
|
bool isTrueValue = value.Equals("true", StringComparison.InvariantCultureIgnoreCase);
|
|||
|
|
jv = new JsonPrimitive(value);
|
|||
|
|
dyn = jv;
|
|||
|
|
Log.Info("IsTrue, {0}", jv);
|
|||
|
|
if (dyn)
|
|||
|
|
{
|
|||
|
|
Assert.True(isTrueValue, "Boolean evaluation should not enter 'if' clause.");
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
Assert.False(isTrueValue, "Boolean evaluation should not enter 'else' clause.");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
foreach (bool first in new bool[] { false, true })
|
|||
|
|
{
|
|||
|
|
dynamic dyn1 = new JsonPrimitive(first);
|
|||
|
|
Log.Info("Negation, {0}", first);
|
|||
|
|
Assert.Equal(!first, !dyn1);
|
|||
|
|
foreach (bool second in new bool[] { false, true })
|
|||
|
|
{
|
|||
|
|
dynamic dyn2 = new JsonPrimitive(second);
|
|||
|
|
Log.Info("Boolean AND, {0} && {1}", first, second);
|
|||
|
|
Assert.Equal(first && second, (bool)(dyn1 && dyn2));
|
|||
|
|
Log.Info("Boolean OR, {0} && {1}", first, second);
|
|||
|
|
Assert.Equal(first || second, (bool)(dyn1 || dyn2));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Log.Info("Invalid boolean operator usage");
|
|||
|
|
dynamic boolDyn = new JsonPrimitive(true);
|
|||
|
|
dynamic intDyn = new JsonPrimitive(1);
|
|||
|
|
dynamic strDyn = new JsonPrimitive("hello");
|
|||
|
|
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info("{0}", !intDyn); });
|
|||
|
|
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info("{0}", !strDyn); });
|
|||
|
|
JsonValueTests.ExpectException<InvalidCastException>(() => { Log.Info("{0}", intDyn && intDyn); });
|
|||
|
|
JsonValueTests.ExpectException<InvalidCastException>(() => { Log.Info("{0}", intDyn || true); });
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info("{0}", boolDyn && 1); });
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info("{0}", boolDyn && intDyn); });
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info("{0}", boolDyn && "hello"); });
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info("{0}", boolDyn && strDyn); });
|
|||
|
|
JsonValueTests.ExpectException<FormatException>(() => { Log.Info("{0}", strDyn && boolDyn); });
|
|||
|
|
JsonValueTests.ExpectException<FormatException>(() => { Log.Info("{0}", strDyn || true); });
|
|||
|
|
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info("{0}", !intDyn.NotHere); });
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info("{0}", !intDyn.NotHere && true); });
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info("{0}", !intDyn.NotHere || false); });
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Tests for using relational operators in dynamic references to <see cref="JsonValue"/> instances.
|
|||
|
|
/// </summary>
|
|||
|
|
[Fact(Skip = "Ignore")]
|
|||
|
|
public void DynamicRelationalOperators()
|
|||
|
|
{
|
|||
|
|
JsonValue jv = new JsonObject { { "one", 1 }, { "one_point_two", 1.2 }, { "decimal_one_point_one", 1.1m }, { "trueValue", true }, { "str", "hello" } };
|
|||
|
|
dynamic dyn = jv;
|
|||
|
|
JsonValue defaultJsonValue = jv.ValueOrDefault(-1);
|
|||
|
|
|
|||
|
|
Log.Info("Equality");
|
|||
|
|
Assert.True(dyn.one == 1);
|
|||
|
|
Assert.True(dyn.one_point_two == 1.2);
|
|||
|
|
Assert.False(dyn.one == 1.2);
|
|||
|
|
Assert.False(dyn.one_point_two == 1);
|
|||
|
|
Assert.False(dyn.one == 2);
|
|||
|
|
Assert.False(dyn.one_point_two == 1.3);
|
|||
|
|
Assert.True(dyn.one == 1m);
|
|||
|
|
Assert.False(dyn.one == 2m);
|
|||
|
|
Assert.True(dyn.decimal_one_point_one == 1.1m);
|
|||
|
|
|
|||
|
|
Assert.True(dyn.NotHere == null);
|
|||
|
|
Assert.True(dyn.NotHere == dyn.NotHere);
|
|||
|
|
Assert.True(dyn.NotHere == defaultJsonValue);
|
|||
|
|
// DISABLED, 197375, Assert.False(dyn.NotHere == 1);
|
|||
|
|
Assert.False(dyn.NotHere == jv);
|
|||
|
|
|
|||
|
|
Log.Info("Inequality");
|
|||
|
|
Assert.False(dyn.one != 1);
|
|||
|
|
Assert.False(dyn.one_point_two != 1.2);
|
|||
|
|
Assert.True(dyn.one != 1.2);
|
|||
|
|
Assert.True(dyn.one_point_two != 1);
|
|||
|
|
Assert.True(dyn.one != 2);
|
|||
|
|
Assert.True(dyn.one_point_two != 1.3);
|
|||
|
|
Assert.False(dyn.one != 1m);
|
|||
|
|
Assert.True(dyn.one != 2m);
|
|||
|
|
|
|||
|
|
Assert.False(dyn.NotHere != null);
|
|||
|
|
Assert.False(dyn.NotHere != dyn.NotHere);
|
|||
|
|
Assert.False(dyn.NotHere != defaultJsonValue);
|
|||
|
|
// DISABLED, 197375, Assert.True(dyn.NotHere != 1);
|
|||
|
|
Assert.True(dyn.NotHere != jv);
|
|||
|
|
|
|||
|
|
Log.Info("Less than");
|
|||
|
|
Assert.True(dyn.one < 2);
|
|||
|
|
Assert.False(dyn.one < 1);
|
|||
|
|
Assert.False(dyn.one < 0);
|
|||
|
|
Assert.True(dyn.one_point_two < 1.3);
|
|||
|
|
Assert.False(dyn.one_point_two < 1.2);
|
|||
|
|
Assert.False(dyn.one_point_two < 1.1);
|
|||
|
|
|
|||
|
|
Assert.True(dyn.one < 1.1);
|
|||
|
|
Assert.Equal(1 < 1.0, dyn.one < 1.0);
|
|||
|
|
Assert.False(dyn.one < 0.9);
|
|||
|
|
Assert.True(dyn.one_point_two < 2);
|
|||
|
|
Assert.False(dyn.one_point_two < 1);
|
|||
|
|
Assert.Equal(1.2 < 1.2f, dyn.one_point_two < 1.2f);
|
|||
|
|
|
|||
|
|
Log.Info("Greater than");
|
|||
|
|
Assert.False(dyn.one > 2);
|
|||
|
|
Assert.False(dyn.one > 1);
|
|||
|
|
Assert.True(dyn.one > 0);
|
|||
|
|
Assert.False(dyn.one_point_two > 1.3);
|
|||
|
|
Assert.False(dyn.one_point_two > 1.2);
|
|||
|
|
Assert.True(dyn.one_point_two > 1.1);
|
|||
|
|
|
|||
|
|
Assert.False(dyn.one > 1.1);
|
|||
|
|
Assert.Equal(1 > 1.0, dyn.one > 1.0);
|
|||
|
|
Assert.True(dyn.one > 0.9);
|
|||
|
|
Assert.False(dyn.one_point_two > 2);
|
|||
|
|
Assert.True(dyn.one_point_two > 1);
|
|||
|
|
Assert.Equal(1.2 > 1.2f, dyn.one_point_two > 1.2f);
|
|||
|
|
|
|||
|
|
Log.Info("Less than or equals");
|
|||
|
|
Assert.True(dyn.one <= 2);
|
|||
|
|
Assert.True(dyn.one <= 1);
|
|||
|
|
Assert.False(dyn.one <= 0);
|
|||
|
|
Assert.True(dyn.one_point_two <= 1.3);
|
|||
|
|
Assert.True(dyn.one_point_two <= 1.2);
|
|||
|
|
Assert.False(dyn.one_point_two <= 1.1);
|
|||
|
|
|
|||
|
|
Assert.True(dyn.one <= 1.1);
|
|||
|
|
Assert.Equal(1 <= 1.0, dyn.one <= 1.0);
|
|||
|
|
Assert.False(dyn.one <= 0.9);
|
|||
|
|
Assert.True(dyn.one_point_two <= 2);
|
|||
|
|
Assert.False(dyn.one_point_two <= 1);
|
|||
|
|
Assert.Equal(1.2 <= 1.2f, dyn.one_point_two <= 1.2f);
|
|||
|
|
|
|||
|
|
Log.Info("Greater than or equals");
|
|||
|
|
Assert.False(dyn.one >= 2);
|
|||
|
|
Assert.True(dyn.one >= 1);
|
|||
|
|
Assert.True(dyn.one >= 0);
|
|||
|
|
Assert.False(dyn.one_point_two >= 1.3);
|
|||
|
|
Assert.True(dyn.one_point_two >= 1.2);
|
|||
|
|
Assert.True(dyn.one_point_two >= 1.1);
|
|||
|
|
|
|||
|
|
Assert.False(dyn.one >= 1.1);
|
|||
|
|
Assert.Equal(1 >= 1.0, dyn.one >= 1.0);
|
|||
|
|
Assert.True(dyn.one >= 0.9);
|
|||
|
|
Assert.False(dyn.one_point_two >= 2);
|
|||
|
|
Assert.True(dyn.one_point_two >= 1);
|
|||
|
|
Assert.Equal(1.2 >= 1.2f, dyn.one_point_two >= 1.2f);
|
|||
|
|
|
|||
|
|
Log.Info("Invalid number conversions");
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info(dyn.decimal_one_point_one == 1.1); });
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info(dyn.one != (uint)2); });
|
|||
|
|
|
|||
|
|
Log.Info("Invalid data types for relational operators");
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info(dyn.trueValue >= dyn.trueValue); });
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info(dyn.NotHere < dyn.NotHere); });
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info(dyn.str < "Jello"); });
|
|||
|
|
|
|||
|
|
// DISABLED, 197315
|
|||
|
|
Log.Info("Conversions from string");
|
|||
|
|
jv = new JsonObject { { "one", "1" }, { "twelve_point_two", "1.22e1" } };
|
|||
|
|
dyn = jv;
|
|||
|
|
Assert.True(dyn.one == 1);
|
|||
|
|
Assert.True(dyn.twelve_point_two == 1.22e1);
|
|||
|
|
Assert.True(dyn.one >= 0.5f);
|
|||
|
|
Assert.True(dyn.twelve_point_two <= 13);
|
|||
|
|
Assert.True(dyn.one < 2);
|
|||
|
|
Assert.Equal(dyn.twelve_point_two.ReadAs<int>() > 12, dyn.twelve_point_two > 12);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Tests for using arithmetic operators in dynamic references to <see cref="JsonValue"/> instances.
|
|||
|
|
/// </summary>
|
|||
|
|
[Fact(Skip = "Ignore")]
|
|||
|
|
public void ArithmeticOperators()
|
|||
|
|
{
|
|||
|
|
int seed = MethodBase.GetCurrentMethod().Name.GetHashCode();
|
|||
|
|
Log.Info("Seed: {0}", seed);
|
|||
|
|
Random rndGen = new Random(seed);
|
|||
|
|
int i1 = rndGen.Next(-10000, 10000);
|
|||
|
|
int i2 = rndGen.Next(-10000, 10000);
|
|||
|
|
JsonValue jv1 = i1;
|
|||
|
|
JsonValue jv2 = i2;
|
|||
|
|
Log.Info("jv1 = {0}, jv2 = {1}", jv1, jv2);
|
|||
|
|
dynamic dyn1 = jv1;
|
|||
|
|
dynamic dyn2 = jv2;
|
|||
|
|
|
|||
|
|
string str1 = i1.ToString(CultureInfo.InvariantCulture);
|
|||
|
|
string str2 = i2.ToString(CultureInfo.InvariantCulture);
|
|||
|
|
JsonValue jvstr1 = str1;
|
|||
|
|
JsonValue jvstr2 = str2;
|
|||
|
|
|
|||
|
|
Log.Info("Unary +");
|
|||
|
|
Assert.Equal<int>(+i1, +dyn1);
|
|||
|
|
Assert.Equal<int>(+i2, +dyn2);
|
|||
|
|
|
|||
|
|
Log.Info("Unary -");
|
|||
|
|
Assert.Equal<int>(-i1, -dyn1);
|
|||
|
|
Assert.Equal<int>(-i2, -dyn2);
|
|||
|
|
|
|||
|
|
Log.Info("Unary ~ (bitwise NOT)");
|
|||
|
|
Assert.Equal<int>(~i1, ~dyn1);
|
|||
|
|
Assert.Equal<int>(~i2, ~dyn2);
|
|||
|
|
|
|||
|
|
Log.Info("Binary +: {0}", i1 + i2);
|
|||
|
|
Assert.Equal<int>(i1 + i2, dyn1 + dyn2);
|
|||
|
|
Assert.Equal<int>(i1 + i2, dyn2 + dyn1);
|
|||
|
|
Assert.Equal<int>(i1 + i2, dyn1 + i2);
|
|||
|
|
Assert.Equal<int>(i1 + i2, dyn2 + i1);
|
|||
|
|
|
|||
|
|
// DISABLED, 197394
|
|||
|
|
// Assert.Equal<int>(i1 + i2, dyn1 + str2);
|
|||
|
|
// Assert.Equal<int>(i1 + i2, dyn1 + jvstr2);
|
|||
|
|
|
|||
|
|
Log.Info("Binary -: {0}, {1}", i1 - i2, i2 - i1);
|
|||
|
|
Assert.Equal<int>(i1 - i2, dyn1 - dyn2);
|
|||
|
|
Assert.Equal<int>(i2 - i1, dyn2 - dyn1);
|
|||
|
|
Assert.Equal<int>(i1 - i2, dyn1 - i2);
|
|||
|
|
Assert.Equal<int>(i2 - i1, dyn2 - i1);
|
|||
|
|
|
|||
|
|
Log.Info("Binary *: {0}", i1 * i2);
|
|||
|
|
Assert.Equal<int>(i1 * i2, dyn1 * dyn2);
|
|||
|
|
Assert.Equal<int>(i1 * i2, dyn2 * dyn1);
|
|||
|
|
Assert.Equal<int>(i1 * i2, dyn1 * i2);
|
|||
|
|
Assert.Equal<int>(i1 * i2, dyn2 * i1);
|
|||
|
|
|
|||
|
|
while (i1 == 0)
|
|||
|
|
{
|
|||
|
|
i1 = rndGen.Next(-10000, 10000);
|
|||
|
|
jv1 = i1;
|
|||
|
|
dyn1 = jv1;
|
|||
|
|
Log.Info("Using new (non-zero) i1 value: {0}", i1);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
while (i2 == 0)
|
|||
|
|
{
|
|||
|
|
i2 = rndGen.Next(-10000, 10000);
|
|||
|
|
jv2 = i2;
|
|||
|
|
dyn2 = jv2;
|
|||
|
|
Log.Info("Using new (non-zero) i2 value: {0}", i2);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Log.Info("Binary / (integer division): {0}, {1}", i1 / i2, i2 / i1);
|
|||
|
|
Assert.Equal<int>(i1 / i2, dyn1 / dyn2);
|
|||
|
|
Assert.Equal<int>(i2 / i1, dyn2 / dyn1);
|
|||
|
|
Assert.Equal<int>(i1 / i2, dyn1 / i2);
|
|||
|
|
Assert.Equal<int>(i2 / i1, dyn2 / i1);
|
|||
|
|
|
|||
|
|
Log.Info("Binary % (modulo): {0}, {1}", i1 % i2, i2 % i1);
|
|||
|
|
Assert.Equal<int>(i1 % i2, dyn1 % dyn2);
|
|||
|
|
Assert.Equal<int>(i2 % i1, dyn2 % dyn1);
|
|||
|
|
Assert.Equal<int>(i1 % i2, dyn1 % i2);
|
|||
|
|
Assert.Equal<int>(i2 % i1, dyn2 % i1);
|
|||
|
|
|
|||
|
|
Log.Info("Binary & (bitwise AND): {0}", i1 & i2);
|
|||
|
|
Assert.Equal<int>(i1 & i2, dyn1 & dyn2);
|
|||
|
|
Assert.Equal<int>(i1 & i2, dyn2 & dyn1);
|
|||
|
|
Assert.Equal<int>(i1 & i2, dyn1 & i2);
|
|||
|
|
Assert.Equal<int>(i1 & i2, dyn2 & i1);
|
|||
|
|
|
|||
|
|
Log.Info("Binary | (bitwise OR): {0}", i1 | i2);
|
|||
|
|
Assert.Equal<int>(i1 | i2, dyn1 | dyn2);
|
|||
|
|
Assert.Equal<int>(i1 | i2, dyn2 | dyn1);
|
|||
|
|
Assert.Equal<int>(i1 | i2, dyn1 | i2);
|
|||
|
|
Assert.Equal<int>(i1 | i2, dyn2 | i1);
|
|||
|
|
|
|||
|
|
Log.Info("Binary ^ (bitwise XOR): {0}", i1 ^ i2);
|
|||
|
|
Assert.Equal<int>(i1 ^ i2, dyn1 ^ dyn2);
|
|||
|
|
Assert.Equal<int>(i1 ^ i2, dyn2 ^ dyn1);
|
|||
|
|
Assert.Equal<int>(i1 ^ i2, dyn1 ^ i2);
|
|||
|
|
Assert.Equal<int>(i1 ^ i2, dyn2 ^ i1);
|
|||
|
|
|
|||
|
|
i1 = rndGen.Next(1, 10);
|
|||
|
|
i2 = rndGen.Next(1, 10);
|
|||
|
|
jv1 = i1;
|
|||
|
|
jv2 = i2;
|
|||
|
|
dyn1 = jv1;
|
|||
|
|
dyn2 = jv2;
|
|||
|
|
Log.Info("New i1, i2: {0}, {1}", i1, i2);
|
|||
|
|
|
|||
|
|
Log.Info("Left shift: {0}", i1 << i2);
|
|||
|
|
Assert.Equal<int>(i1 << i2, dyn1 << dyn2);
|
|||
|
|
Assert.Equal<int>(i1 << i2, dyn1 << i2);
|
|||
|
|
|
|||
|
|
i1 = i1 << i2;
|
|||
|
|
jv1 = i1;
|
|||
|
|
dyn1 = jv1;
|
|||
|
|
Log.Info("New i1: {0}", i1);
|
|||
|
|
Log.Info("Right shift: {0}", i1 >> i2);
|
|||
|
|
Assert.Equal<int>(i1 >> i2, dyn1 >> dyn2);
|
|||
|
|
Assert.Equal<int>(i1 >> i2, dyn1 >> i2);
|
|||
|
|
|
|||
|
|
i2 += 4;
|
|||
|
|
jv2 = i2;
|
|||
|
|
dyn2 = jv2;
|
|||
|
|
Log.Info("New i2: {0}", i2);
|
|||
|
|
Log.Info("Right shift: {0}", i1 >> i2);
|
|||
|
|
Assert.Equal<int>(i1 >> i2, dyn1 >> dyn2);
|
|||
|
|
Assert.Equal<int>(i1 >> i2, dyn1 >> i2);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Tests for conversions between data types in arithmetic operations.
|
|||
|
|
/// </summary>
|
|||
|
|
[Fact(Skip = "Ignore")]
|
|||
|
|
public void ArithmeticConversion()
|
|||
|
|
{
|
|||
|
|
JsonObject jo = new JsonObject
|
|||
|
|
{
|
|||
|
|
{ "byteVal", (byte)10 },
|
|||
|
|
{ "sbyteVal", (sbyte)10 },
|
|||
|
|
{ "shortVal", (short)10 },
|
|||
|
|
{ "ushortVal", (ushort)10 },
|
|||
|
|
{ "intVal", 10 },
|
|||
|
|
{ "uintVal", (uint)10 },
|
|||
|
|
{ "longVal", 10L },
|
|||
|
|
{ "ulongVal", (ulong)10 },
|
|||
|
|
{ "charVal", (char)10 },
|
|||
|
|
{ "decimalVal", 10m },
|
|||
|
|
{ "doubleVal", 10.0 },
|
|||
|
|
{ "floatVal", 10f },
|
|||
|
|
};
|
|||
|
|
dynamic dyn = jo;
|
|||
|
|
|
|||
|
|
Log.Info("Conversion from byte");
|
|||
|
|
// DISABLED, 197387, ValidateResult<int>(dyn.byteVal + (byte)10, 20);
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.byteVal + (sbyte)10));
|
|||
|
|
ValidateResult<short>(dyn.byteVal + (short)10, 20);
|
|||
|
|
ValidateResult<ushort>(dyn.byteVal + (ushort)10, 20);
|
|||
|
|
ValidateResult<int>(dyn.byteVal + (int)10, 20);
|
|||
|
|
ValidateResult<uint>(dyn.byteVal + (uint)10, 20);
|
|||
|
|
ValidateResult<long>(dyn.byteVal + 10L, 20);
|
|||
|
|
ValidateResult<ulong>(dyn.byteVal + (ulong)10, 20);
|
|||
|
|
ValidateResult<decimal>(dyn.byteVal + 10m, 20);
|
|||
|
|
ValidateResult<float>(dyn.byteVal + 10f, 20);
|
|||
|
|
ValidateResult<double>(dyn.byteVal + 10.0, 20);
|
|||
|
|
|
|||
|
|
Log.Info("Conversion from sbyte");
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.sbyteVal + (byte)10));
|
|||
|
|
// DISABLED, 197387, ValidateResult<int>(dyn.sbyteVal + (sbyte)10, 20);
|
|||
|
|
ValidateResult<short>(dyn.sbyteVal + (short)10, 20);
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.sbyteVal + (ushort)10));
|
|||
|
|
ValidateResult<int>(dyn.sbyteVal + (int)10, 20);
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.sbyteVal + (uint)10));
|
|||
|
|
ValidateResult<long>(dyn.sbyteVal + 10L, 20);
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.sbyteVal + (ulong)10));
|
|||
|
|
ValidateResult<decimal>(dyn.sbyteVal + 10m, 20);
|
|||
|
|
ValidateResult<float>(dyn.sbyteVal + 10f, 20);
|
|||
|
|
ValidateResult<double>(dyn.sbyteVal + 10.0, 20);
|
|||
|
|
|
|||
|
|
Log.Info("Conversion from short");
|
|||
|
|
ValidateResult<short>(dyn.shortVal + (byte)10, 20);
|
|||
|
|
ValidateResult<short>(dyn.shortVal + (sbyte)10, 20);
|
|||
|
|
ValidateResult<short>(dyn.shortVal + (short)10, 20);
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.shortVal + (ushort)10));
|
|||
|
|
ValidateResult<int>(dyn.shortVal + (int)10, 20);
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.shortVal + (uint)10));
|
|||
|
|
ValidateResult<long>(dyn.shortVal + 10L, 20);
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.shortVal + (ulong)10));
|
|||
|
|
ValidateResult<decimal>(dyn.shortVal + 10m, 20);
|
|||
|
|
ValidateResult<float>(dyn.shortVal + 10f, 20);
|
|||
|
|
ValidateResult<double>(dyn.shortVal + 10.0, 20);
|
|||
|
|
|
|||
|
|
Log.Info("Conversion from ushort");
|
|||
|
|
ValidateResult<ushort>(dyn.ushortVal + (byte)10, 20);
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.ushortVal + (sbyte)10));
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.ushortVal + (short)10));
|
|||
|
|
ValidateResult<ushort>(dyn.ushortVal + (ushort)10, 20);
|
|||
|
|
ValidateResult<int>(dyn.ushortVal + (int)10, 20);
|
|||
|
|
ValidateResult<uint>(dyn.ushortVal + (uint)10, 20);
|
|||
|
|
ValidateResult<long>(dyn.ushortVal + 10L, 20);
|
|||
|
|
ValidateResult<ulong>(dyn.ushortVal + (ulong)10, 20);
|
|||
|
|
ValidateResult<decimal>(dyn.ushortVal + 10m, 20);
|
|||
|
|
ValidateResult<float>(dyn.ushortVal + 10f, 20);
|
|||
|
|
ValidateResult<double>(dyn.ushortVal + 10.0, 20);
|
|||
|
|
|
|||
|
|
Log.Info("Conversion from int");
|
|||
|
|
ValidateResult<int>(dyn.intVal + (byte)10, 20);
|
|||
|
|
ValidateResult<int>(dyn.intVal + (sbyte)10, 20);
|
|||
|
|
ValidateResult<int>(dyn.intVal + (short)10, 20);
|
|||
|
|
ValidateResult<int>(dyn.intVal + (ushort)10, 20);
|
|||
|
|
ValidateResult<int>(dyn.intVal + (int)10, 20);
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.intVal + (uint)10));
|
|||
|
|
ValidateResult<long>(dyn.intVal + 10L, 20);
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.intVal + (ulong)10));
|
|||
|
|
ValidateResult<decimal>(dyn.intVal + 10m, 20);
|
|||
|
|
ValidateResult<float>(dyn.intVal + 10f, 20);
|
|||
|
|
ValidateResult<double>(dyn.intVal + 10.0, 20);
|
|||
|
|
|
|||
|
|
Log.Info("Conversion from uint");
|
|||
|
|
ValidateResult<uint>(dyn.uintVal + (byte)10, 20);
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.uintVal + (sbyte)10));
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.uintVal + (short)10));
|
|||
|
|
ValidateResult<uint>(dyn.uintVal + (ushort)10, 20);
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.uintVal + (int)10));
|
|||
|
|
ValidateResult<uint>(dyn.uintVal + (uint)10, 20);
|
|||
|
|
ValidateResult<long>(dyn.uintVal + 10L, 20);
|
|||
|
|
ValidateResult<ulong>(dyn.uintVal + (ulong)10, 20);
|
|||
|
|
ValidateResult<decimal>(dyn.uintVal + 10m, 20);
|
|||
|
|
ValidateResult<float>(dyn.uintVal + 10f, 20);
|
|||
|
|
ValidateResult<double>(dyn.uintVal + 10.0, 20);
|
|||
|
|
|
|||
|
|
Log.Info("Conversion from long");
|
|||
|
|
ValidateResult<long>(dyn.longVal + (byte)10, 20);
|
|||
|
|
ValidateResult<long>(dyn.longVal + (sbyte)10, 20);
|
|||
|
|
ValidateResult<long>(dyn.longVal + (short)10, 20);
|
|||
|
|
ValidateResult<long>(dyn.longVal + (ushort)10, 20);
|
|||
|
|
ValidateResult<long>(dyn.longVal + (int)10, 20);
|
|||
|
|
ValidateResult<long>(dyn.longVal + (uint)10, 20);
|
|||
|
|
ValidateResult<long>(dyn.longVal + 10L, 20);
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.longVal + (ulong)10));
|
|||
|
|
ValidateResult<decimal>(dyn.longVal + 10m, 20);
|
|||
|
|
ValidateResult<float>(dyn.longVal + 10f, 20);
|
|||
|
|
ValidateResult<double>(dyn.longVal + 10.0, 20);
|
|||
|
|
|
|||
|
|
Log.Info("Conversion from ulong");
|
|||
|
|
ValidateResult<ulong>(dyn.ulongVal + (byte)10, 20);
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.ulongVal + (sbyte)10));
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.ulongVal + (short)10));
|
|||
|
|
ValidateResult<ulong>(dyn.ulongVal + (ushort)10, 20);
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.ulongVal + (int)10));
|
|||
|
|
ValidateResult<ulong>(dyn.ulongVal + (uint)10, 20);
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.ulongVal + (long)10));
|
|||
|
|
ValidateResult<ulong>(dyn.ulongVal + (ulong)10, 20);
|
|||
|
|
ValidateResult<decimal>(dyn.ulongVal + 10m, 20);
|
|||
|
|
ValidateResult<float>(dyn.ulongVal + 10f, 20);
|
|||
|
|
ValidateResult<double>(dyn.ulongVal + 10.0, 20);
|
|||
|
|
|
|||
|
|
Log.Info("Conversion from float");
|
|||
|
|
ValidateResult<float>(dyn.floatVal + (byte)10, 20);
|
|||
|
|
ValidateResult<float>(dyn.floatVal + (sbyte)10, 20);
|
|||
|
|
ValidateResult<float>(dyn.floatVal + (short)10, 20);
|
|||
|
|
ValidateResult<float>(dyn.floatVal + (ushort)10, 20);
|
|||
|
|
ValidateResult<float>(dyn.floatVal + (int)10, 20);
|
|||
|
|
ValidateResult<float>(dyn.floatVal + (uint)10, 20);
|
|||
|
|
ValidateResult<float>(dyn.floatVal + 10L, 20);
|
|||
|
|
ValidateResult<float>(dyn.floatVal + (ulong)10, 20);
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.floatVal + 10m));
|
|||
|
|
ValidateResult<float>(dyn.floatVal + 10f, 20);
|
|||
|
|
ValidateResult<double>(dyn.floatVal + 10.0, 20);
|
|||
|
|
|
|||
|
|
Log.Info("Conversion from double");
|
|||
|
|
ValidateResult<double>(dyn.doubleVal + (byte)10, 20);
|
|||
|
|
ValidateResult<double>(dyn.doubleVal + (sbyte)10, 20);
|
|||
|
|
ValidateResult<double>(dyn.doubleVal + (short)10, 20);
|
|||
|
|
ValidateResult<double>(dyn.doubleVal + (ushort)10, 20);
|
|||
|
|
ValidateResult<double>(dyn.doubleVal + (int)10, 20);
|
|||
|
|
ValidateResult<double>(dyn.doubleVal + (uint)10, 20);
|
|||
|
|
ValidateResult<double>(dyn.doubleVal + 10L, 20);
|
|||
|
|
ValidateResult<double>(dyn.doubleVal + (ulong)10, 20);
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.doubleVal + 10m));
|
|||
|
|
ValidateResult<double>(dyn.doubleVal + 10f, 20);
|
|||
|
|
ValidateResult<double>(dyn.doubleVal + 10.0, 20);
|
|||
|
|
|
|||
|
|
Log.Info("Conversion from decimal");
|
|||
|
|
ValidateResult<decimal>(dyn.decimalVal + (byte)10, 20);
|
|||
|
|
ValidateResult<decimal>(dyn.decimalVal + (sbyte)10, 20);
|
|||
|
|
ValidateResult<decimal>(dyn.decimalVal + (short)10, 20);
|
|||
|
|
ValidateResult<decimal>(dyn.decimalVal + (ushort)10, 20);
|
|||
|
|
ValidateResult<decimal>(dyn.decimalVal + (int)10, 20);
|
|||
|
|
ValidateResult<decimal>(dyn.decimalVal + (uint)10, 20);
|
|||
|
|
ValidateResult<decimal>(dyn.decimalVal + 10L, 20);
|
|||
|
|
ValidateResult<decimal>(dyn.decimalVal + (ulong)10, 20);
|
|||
|
|
ValidateResult<decimal>(dyn.decimalVal + 10m, 20);
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.decimalVal + 10f));
|
|||
|
|
JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.decimalVal + 10.0));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Tests for implicit casts between dynamic references to <see cref="JsonPrimitive"/> instances
|
|||
|
|
/// and the supported CLR types.
|
|||
|
|
/// </summary>
|
|||
|
|
[Fact]
|
|||
|
|
public void ImplicitPrimitiveCastTests()
|
|||
|
|
{
|
|||
|
|
DateTime now = DateTime.Now;
|
|||
|
|
int seed = now.Year * 10000 + now.Month * 100 + now.Day;
|
|||
|
|
Log.Info("Seed: {0}", seed);
|
|||
|
|
Random rndGen = new Random(seed);
|
|||
|
|
int intValue = rndGen.Next(1, 127);
|
|||
|
|
Log.Info("Value: {0}", intValue);
|
|||
|
|
|
|||
|
|
uint uintValue = (uint)intValue;
|
|||
|
|
short shortValue = (short)intValue;
|
|||
|
|
ushort ushortValue = (ushort)intValue;
|
|||
|
|
long longValue = (long)intValue;
|
|||
|
|
ulong ulongValue = (ulong)intValue;
|
|||
|
|
byte byteValue = (byte)intValue;
|
|||
|
|
sbyte sbyteValue = (sbyte)intValue;
|
|||
|
|
float floatValue = (float)intValue;
|
|||
|
|
double doubleValue = (double)intValue;
|
|||
|
|
decimal decimalValue = (decimal)intValue;
|
|||
|
|
string stringValue = intValue.ToString(CultureInfo.InvariantCulture);
|
|||
|
|
|
|||
|
|
dynamic dyn = new JsonObject
|
|||
|
|
{
|
|||
|
|
{ "Byte", byteValue },
|
|||
|
|
{ "SByte", sbyteValue },
|
|||
|
|
{ "Int16", shortValue },
|
|||
|
|
{ "UInt16", ushortValue },
|
|||
|
|
{ "Int32", intValue },
|
|||
|
|
{ "UInt32", uintValue },
|
|||
|
|
{ "Int64", longValue },
|
|||
|
|
{ "UInt64", ulongValue },
|
|||
|
|
{ "Double", doubleValue },
|
|||
|
|
{ "Single", floatValue },
|
|||
|
|
{ "Decimal", decimalValue },
|
|||
|
|
{ "String", stringValue },
|
|||
|
|
{ "True", "true" },
|
|||
|
|
{ "False", "false" },
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Log.Info("dyn: {0}", dyn);
|
|||
|
|
|
|||
|
|
Log.Info("Casts to Byte");
|
|||
|
|
|
|||
|
|
byte byteFromByte = dyn.Byte;
|
|||
|
|
byte byteFromSByte = dyn.SByte;
|
|||
|
|
byte byteFromShort = dyn.Int16;
|
|||
|
|
byte byteFromUShort = dyn.UInt16;
|
|||
|
|
byte byteFromInt = dyn.Int32;
|
|||
|
|
byte byteFromUInt = dyn.UInt32;
|
|||
|
|
byte byteFromLong = dyn.Int64;
|
|||
|
|
byte byteFromULong = dyn.UInt64;
|
|||
|
|
byte byteFromDouble = dyn.Double;
|
|||
|
|
byte byteFromFloat = dyn.Single;
|
|||
|
|
byte byteFromDecimal = dyn.Decimal;
|
|||
|
|
byte byteFromString = dyn.String;
|
|||
|
|
|
|||
|
|
Assert.Equal<byte>(byteValue, byteFromByte);
|
|||
|
|
Assert.Equal<byte>(byteValue, byteFromSByte);
|
|||
|
|
Assert.Equal<byte>(byteValue, byteFromShort);
|
|||
|
|
Assert.Equal<byte>(byteValue, byteFromUShort);
|
|||
|
|
Assert.Equal<byte>(byteValue, byteFromInt);
|
|||
|
|
Assert.Equal<byte>(byteValue, byteFromUInt);
|
|||
|
|
Assert.Equal<byte>(byteValue, byteFromLong);
|
|||
|
|
Assert.Equal<byte>(byteValue, byteFromULong);
|
|||
|
|
Assert.Equal<byte>(byteValue, byteFromDouble);
|
|||
|
|
Assert.Equal<byte>(byteValue, byteFromFloat);
|
|||
|
|
Assert.Equal<byte>(byteValue, byteFromDecimal);
|
|||
|
|
Assert.Equal<byte>(byteValue, byteFromString);
|
|||
|
|
|
|||
|
|
Log.Info("Casts to SByte");
|
|||
|
|
|
|||
|
|
sbyte sbyteFromByte = dyn.Byte;
|
|||
|
|
sbyte sbyteFromSByte = dyn.SByte;
|
|||
|
|
sbyte sbyteFromShort = dyn.Int16;
|
|||
|
|
sbyte sbyteFromUShort = dyn.UInt16;
|
|||
|
|
sbyte sbyteFromInt = dyn.Int32;
|
|||
|
|
sbyte sbyteFromUInt = dyn.UInt32;
|
|||
|
|
sbyte sbyteFromLong = dyn.Int64;
|
|||
|
|
sbyte sbyteFromULong = dyn.UInt64;
|
|||
|
|
sbyte sbyteFromDouble = dyn.Double;
|
|||
|
|
sbyte sbyteFromFloat = dyn.Single;
|
|||
|
|
sbyte sbyteFromDecimal = dyn.Decimal;
|
|||
|
|
sbyte sbyteFromString = dyn.String;
|
|||
|
|
|
|||
|
|
Assert.Equal<sbyte>(sbyteValue, sbyteFromByte);
|
|||
|
|
Assert.Equal<sbyte>(sbyteValue, sbyteFromSByte);
|
|||
|
|
Assert.Equal<sbyte>(sbyteValue, sbyteFromShort);
|
|||
|
|
Assert.Equal<sbyte>(sbyteValue, sbyteFromUShort);
|
|||
|
|
Assert.Equal<sbyte>(sbyteValue, sbyteFromInt);
|
|||
|
|
Assert.Equal<sbyte>(sbyteValue, sbyteFromUInt);
|
|||
|
|
Assert.Equal<sbyte>(sbyteValue, sbyteFromLong);
|
|||
|
|
Assert.Equal<sbyte>(sbyteValue, sbyteFromULong);
|
|||
|
|
Assert.Equal<sbyte>(sbyteValue, sbyteFromDouble);
|
|||
|
|
Assert.Equal<sbyte>(sbyteValue, sbyteFromFloat);
|
|||
|
|
Assert.Equal<sbyte>(sbyteValue, sbyteFromDecimal);
|
|||
|
|
Assert.Equal<sbyte>(sbyteValue, sbyteFromString);
|
|||
|
|
|
|||
|
|
Log.Info("Casts to Short");
|
|||
|
|
|
|||
|
|
short shortFromByte = dyn.Byte;
|
|||
|
|
short shortFromSByte = dyn.SByte;
|
|||
|
|
short shortFromShort = dyn.Int16;
|
|||
|
|
short shortFromUShort = dyn.UInt16;
|
|||
|
|
short shortFromInt = dyn.Int32;
|
|||
|
|
short shortFromUInt = dyn.UInt32;
|
|||
|
|
short shortFromLong = dyn.Int64;
|
|||
|
|
short shortFromULong = dyn.UInt64;
|
|||
|
|
short shortFromDouble = dyn.Double;
|
|||
|
|
short shortFromFloat = dyn.Single;
|
|||
|
|
short shortFromDecimal = dyn.Decimal;
|
|||
|
|
short shortFromString = dyn.String;
|
|||
|
|
|
|||
|
|
Assert.Equal<short>(shortValue, shortFromByte);
|
|||
|
|
Assert.Equal<short>(shortValue, shortFromSByte);
|
|||
|
|
Assert.Equal<short>(shortValue, shortFromShort);
|
|||
|
|
Assert.Equal<short>(shortValue, shortFromUShort);
|
|||
|
|
Assert.Equal<short>(shortValue, shortFromInt);
|
|||
|
|
Assert.Equal<short>(shortValue, shortFromUInt);
|
|||
|
|
Assert.Equal<short>(shortValue, shortFromLong);
|
|||
|
|
Assert.Equal<short>(shortValue, shortFromULong);
|
|||
|
|
Assert.Equal<short>(shortValue, shortFromDouble);
|
|||
|
|
Assert.Equal<short>(shortValue, shortFromFloat);
|
|||
|
|
Assert.Equal<short>(shortValue, shortFromDecimal);
|
|||
|
|
Assert.Equal<short>(shortValue, shortFromString);
|
|||
|
|
|
|||
|
|
Log.Info("Casts to UShort");
|
|||
|
|
|
|||
|
|
ushort ushortFromByte = dyn.Byte;
|
|||
|
|
ushort ushortFromSByte = dyn.SByte;
|
|||
|
|
ushort ushortFromShort = dyn.Int16;
|
|||
|
|
ushort ushortFromUShort = dyn.UInt16;
|
|||
|
|
ushort ushortFromInt = dyn.Int32;
|
|||
|
|
ushort ushortFromUInt = dyn.UInt32;
|
|||
|
|
ushort ushortFromLong = dyn.Int64;
|
|||
|
|
ushort ushortFromULong = dyn.UInt64;
|
|||
|
|
ushort ushortFromDouble = dyn.Double;
|
|||
|
|
ushort ushortFromFloat = dyn.Single;
|
|||
|
|
ushort ushortFromDecimal = dyn.Decimal;
|
|||
|
|
ushort ushortFromString = dyn.String;
|
|||
|
|
|
|||
|
|
Assert.Equal<ushort>(ushortValue, ushortFromByte);
|
|||
|
|
Assert.Equal<ushort>(ushortValue, ushortFromSByte);
|
|||
|
|
Assert.Equal<ushort>(ushortValue, ushortFromShort);
|
|||
|
|
Assert.Equal<ushort>(ushortValue, ushortFromUShort);
|
|||
|
|
Assert.Equal<ushort>(ushortValue, ushortFromInt);
|
|||
|
|
Assert.Equal<ushort>(ushortValue, ushortFromUInt);
|
|||
|
|
Assert.Equal<ushort>(ushortValue, ushortFromLong);
|
|||
|
|
Assert.Equal<ushort>(ushortValue, ushortFromULong);
|
|||
|
|
Assert.Equal<ushort>(ushortValue, ushortFromDouble);
|
|||
|
|
Assert.Equal<ushort>(ushortValue, ushortFromFloat);
|
|||
|
|
Assert.Equal<ushort>(ushortValue, ushortFromDecimal);
|
|||
|
|
Assert.Equal<ushort>(ushortValue, ushortFromString);
|
|||
|
|
|
|||
|
|
Log.Info("Casts to Int");
|
|||
|
|
|
|||
|
|
int intFromByte = dyn.Byte;
|
|||
|
|
int intFromSByte = dyn.SByte;
|
|||
|
|
int intFromShort = dyn.Int16;
|
|||
|
|
int intFromUShort = dyn.UInt16;
|
|||
|
|
int intFromInt = dyn.Int32;
|
|||
|
|
int intFromUInt = dyn.UInt32;
|
|||
|
|
int intFromLong = dyn.Int64;
|
|||
|
|
int intFromULong = dyn.UInt64;
|
|||
|
|
int intFromDouble = dyn.Double;
|
|||
|
|
int intFromFloat = dyn.Single;
|
|||
|
|
int intFromDecimal = dyn.Decimal;
|
|||
|
|
int intFromString = dyn.String;
|
|||
|
|
|
|||
|
|
Assert.Equal<int>(intValue, intFromByte);
|
|||
|
|
Assert.Equal<int>(intValue, intFromSByte);
|
|||
|
|
Assert.Equal<int>(intValue, intFromShort);
|
|||
|
|
Assert.Equal<int>(intValue, intFromUShort);
|
|||
|
|
Assert.Equal<int>(intValue, intFromInt);
|
|||
|
|
Assert.Equal<int>(intValue, intFromUInt);
|
|||
|
|
Assert.Equal<int>(intValue, intFromLong);
|
|||
|
|
Assert.Equal<int>(intValue, intFromULong);
|
|||
|
|
Assert.Equal<int>(intValue, intFromDouble);
|
|||
|
|
Assert.Equal<int>(intValue, intFromFloat);
|
|||
|
|
Assert.Equal<int>(intValue, intFromDecimal);
|
|||
|
|
Assert.Equal<int>(intValue, intFromString);
|
|||
|
|
|
|||
|
|
Log.Info("Casts to UInt");
|
|||
|
|
|
|||
|
|
uint uintFromByte = dyn.Byte;
|
|||
|
|
uint uintFromSByte = dyn.SByte;
|
|||
|
|
uint uintFromShort = dyn.Int16;
|
|||
|
|
uint uintFromUShort = dyn.UInt16;
|
|||
|
|
uint uintFromInt = dyn.Int32;
|
|||
|
|
uint uintFromUInt = dyn.UInt32;
|
|||
|
|
uint uintFromLong = dyn.Int64;
|
|||
|
|
uint uintFromULong = dyn.UInt64;
|
|||
|
|
uint uintFromDouble = dyn.Double;
|
|||
|
|
uint uintFromFloat = dyn.Single;
|
|||
|
|
uint uintFromDecimal = dyn.Decimal;
|
|||
|
|
uint uintFromString = dyn.String;
|
|||
|
|
|
|||
|
|
Assert.Equal<uint>(uintValue, uintFromByte);
|
|||
|
|
Assert.Equal<uint>(uintValue, uintFromSByte);
|
|||
|
|
Assert.Equal<uint>(uintValue, uintFromShort);
|
|||
|
|
Assert.Equal<uint>(uintValue, uintFromUShort);
|
|||
|
|
Assert.Equal<uint>(uintValue, uintFromInt);
|
|||
|
|
Assert.Equal<uint>(uintValue, uintFromUInt);
|
|||
|
|
Assert.Equal<uint>(uintValue, uintFromLong);
|
|||
|
|
Assert.Equal<uint>(uintValue, uintFromULong);
|
|||
|
|
Assert.Equal<uint>(uintValue, uintFromDouble);
|
|||
|
|
Assert.Equal<uint>(uintValue, uintFromFloat);
|
|||
|
|
Assert.Equal<uint>(uintValue, uintFromDecimal);
|
|||
|
|
Assert.Equal<uint>(uintValue, uintFromString);
|
|||
|
|
|
|||
|
|
Log.Info("Casts to Long");
|
|||
|
|
|
|||
|
|
long longFromByte = dyn.Byte;
|
|||
|
|
long longFromSByte = dyn.SByte;
|
|||
|
|
long longFromShort = dyn.Int16;
|
|||
|
|
long longFromUShort = dyn.UInt16;
|
|||
|
|
long longFromInt = dyn.Int32;
|
|||
|
|
long longFromUInt = dyn.UInt32;
|
|||
|
|
long longFromLong = dyn.Int64;
|
|||
|
|
long longFromULong = dyn.UInt64;
|
|||
|
|
long longFromDouble = dyn.Double;
|
|||
|
|
long longFromFloat = dyn.Single;
|
|||
|
|
long longFromDecimal = dyn.Decimal;
|
|||
|
|
long longFromString = dyn.String;
|
|||
|
|
|
|||
|
|
Assert.Equal<long>(longValue, longFromByte);
|
|||
|
|
Assert.Equal<long>(longValue, longFromSByte);
|
|||
|
|
Assert.Equal<long>(longValue, longFromShort);
|
|||
|
|
Assert.Equal<long>(longValue, longFromUShort);
|
|||
|
|
Assert.Equal<long>(longValue, longFromInt);
|
|||
|
|
Assert.Equal<long>(longValue, longFromUInt);
|
|||
|
|
Assert.Equal<long>(longValue, longFromLong);
|
|||
|
|
Assert.Equal<long>(longValue, longFromULong);
|
|||
|
|
Assert.Equal<long>(longValue, longFromDouble);
|
|||
|
|
Assert.Equal<long>(longValue, longFromFloat);
|
|||
|
|
Assert.Equal<long>(longValue, longFromDecimal);
|
|||
|
|
Assert.Equal<long>(longValue, longFromString);
|
|||
|
|
|
|||
|
|
Log.Info("Casts to ULong");
|
|||
|
|
|
|||
|
|
ulong ulongFromByte = dyn.Byte;
|
|||
|
|
ulong ulongFromSByte = dyn.SByte;
|
|||
|
|
ulong ulongFromShort = dyn.Int16;
|
|||
|
|
ulong ulongFromUShort = dyn.UInt16;
|
|||
|
|
ulong ulongFromInt = dyn.Int32;
|
|||
|
|
ulong ulongFromUInt = dyn.UInt32;
|
|||
|
|
ulong ulongFromLong = dyn.Int64;
|
|||
|
|
ulong ulongFromULong = dyn.UInt64;
|
|||
|
|
ulong ulongFromDouble = dyn.Double;
|
|||
|
|
ulong ulongFromFloat = dyn.Single;
|
|||
|
|
ulong ulongFromDecimal = dyn.Decimal;
|
|||
|
|
ulong ulongFromString = dyn.String;
|
|||
|
|
|
|||
|
|
Assert.Equal<ulong>(ulongValue, ulongFromByte);
|
|||
|
|
Assert.Equal<ulong>(ulongValue, ulongFromSByte);
|
|||
|
|
Assert.Equal<ulong>(ulongValue, ulongFromShort);
|
|||
|
|
Assert.Equal<ulong>(ulongValue, ulongFromUShort);
|
|||
|
|
Assert.Equal<ulong>(ulongValue, ulongFromInt);
|
|||
|
|
Assert.Equal<ulong>(ulongValue, ulongFromUInt);
|
|||
|
|
Assert.Equal<ulong>(ulongValue, ulongFromLong);
|
|||
|
|
Assert.Equal<ulong>(ulongValue, ulongFromULong);
|
|||
|
|
Assert.Equal<ulong>(ulongValue, ulongFromDouble);
|
|||
|
|
Assert.Equal<ulong>(ulongValue, ulongFromFloat);
|
|||
|
|
Assert.Equal<ulong>(ulongValue, ulongFromDecimal);
|
|||
|
|
Assert.Equal<ulong>(ulongValue, ulongFromString);
|
|||
|
|
|
|||
|
|
Log.Info("Casts to Float");
|
|||
|
|
|
|||
|
|
float floatFromByte = dyn.Byte;
|
|||
|
|
float floatFromSByte = dyn.SByte;
|
|||
|
|
float floatFromShort = dyn.Int16;
|
|||
|
|
float floatFromUShort = dyn.UInt16;
|
|||
|
|
float floatFromInt = dyn.Int32;
|
|||
|
|
float floatFromUInt = dyn.UInt32;
|
|||
|
|
float floatFromLong = dyn.Int64;
|
|||
|
|
float floatFromULong = dyn.UInt64;
|
|||
|
|
float floatFromDouble = dyn.Double;
|
|||
|
|
float floatFromFloat = dyn.Single;
|
|||
|
|
float floatFromDecimal = dyn.Decimal;
|
|||
|
|
float floatFromString = dyn.String;
|
|||
|
|
|
|||
|
|
Assert.Equal<float>(floatValue, floatFromByte);
|
|||
|
|
Assert.Equal<float>(floatValue, floatFromSByte);
|
|||
|
|
Assert.Equal<float>(floatValue, floatFromShort);
|
|||
|
|
Assert.Equal<float>(floatValue, floatFromUShort);
|
|||
|
|
Assert.Equal<float>(floatValue, floatFromInt);
|
|||
|
|
Assert.Equal<float>(floatValue, floatFromUInt);
|
|||
|
|
Assert.Equal<float>(floatValue, floatFromLong);
|
|||
|
|
Assert.Equal<float>(floatValue, floatFromULong);
|
|||
|
|
Assert.Equal<float>(floatValue, floatFromDouble);
|
|||
|
|
Assert.Equal<float>(floatValue, floatFromFloat);
|
|||
|
|
Assert.Equal<float>(floatValue, floatFromDecimal);
|
|||
|
|
Assert.Equal<float>(floatValue, floatFromString);
|
|||
|
|
|
|||
|
|
Log.Info("Casts to Double");
|
|||
|
|
|
|||
|
|
double doubleFromByte = dyn.Byte;
|
|||
|
|
double doubleFromSByte = dyn.SByte;
|
|||
|
|
double doubleFromShort = dyn.Int16;
|
|||
|
|
double doubleFromUShort = dyn.UInt16;
|
|||
|
|
double doubleFromInt = dyn.Int32;
|
|||
|
|
double doubleFromUInt = dyn.UInt32;
|
|||
|
|
double doubleFromLong = dyn.Int64;
|
|||
|
|
double doubleFromULong = dyn.UInt64;
|
|||
|
|
double doubleFromDouble = dyn.Double;
|
|||
|
|
double doubleFromFloat = dyn.Single;
|
|||
|
|
double doubleFromDecimal = dyn.Decimal;
|
|||
|
|
double doubleFromString = dyn.String;
|
|||
|
|
|
|||
|
|
Assert.Equal<double>(doubleValue, doubleFromByte);
|
|||
|
|
Assert.Equal<double>(doubleValue, doubleFromSByte);
|
|||
|
|
Assert.Equal<double>(doubleValue, doubleFromShort);
|
|||
|
|
Assert.Equal<double>(doubleValue, doubleFromUShort);
|
|||
|
|
Assert.Equal<double>(doubleValue, doubleFromInt);
|
|||
|
|
Assert.Equal<double>(doubleValue, doubleFromUInt);
|
|||
|
|
Assert.Equal<double>(doubleValue, doubleFromLong);
|
|||
|
|
Assert.Equal<double>(doubleValue, doubleFromULong);
|
|||
|
|
Assert.Equal<double>(doubleValue, doubleFromDouble);
|
|||
|
|
Assert.Equal<double>(doubleValue, doubleFromFloat);
|
|||
|
|
Assert.Equal<double>(doubleValue, doubleFromDecimal);
|
|||
|
|
Assert.Equal<double>(doubleValue, doubleFromString);
|
|||
|
|
|
|||
|
|
Log.Info("Casts to Decimal");
|
|||
|
|
|
|||
|
|
decimal decimalFromByte = dyn.Byte;
|
|||
|
|
decimal decimalFromSByte = dyn.SByte;
|
|||
|
|
decimal decimalFromShort = dyn.Int16;
|
|||
|
|
decimal decimalFromUShort = dyn.UInt16;
|
|||
|
|
decimal decimalFromInt = dyn.Int32;
|
|||
|
|
decimal decimalFromUInt = dyn.UInt32;
|
|||
|
|
decimal decimalFromLong = dyn.Int64;
|
|||
|
|
decimal decimalFromULong = dyn.UInt64;
|
|||
|
|
decimal decimalFromDouble = dyn.Double;
|
|||
|
|
decimal decimalFromFloat = dyn.Single;
|
|||
|
|
decimal decimalFromDecimal = dyn.Decimal;
|
|||
|
|
decimal decimalFromString = dyn.String;
|
|||
|
|
|
|||
|
|
Assert.Equal<decimal>(decimalValue, decimalFromByte);
|
|||
|
|
Assert.Equal<decimal>(decimalValue, decimalFromSByte);
|
|||
|
|
Assert.Equal<decimal>(decimalValue, decimalFromShort);
|
|||
|
|
Assert.Equal<decimal>(decimalValue, decimalFromUShort);
|
|||
|
|
Assert.Equal<decimal>(decimalValue, decimalFromInt);
|
|||
|
|
Assert.Equal<decimal>(decimalValue, decimalFromUInt);
|
|||
|
|
Assert.Equal<decimal>(decimalValue, decimalFromLong);
|
|||
|
|
Assert.Equal<decimal>(decimalValue, decimalFromULong);
|
|||
|
|
Assert.Equal<decimal>(decimalValue, decimalFromDouble);
|
|||
|
|
Assert.Equal<decimal>(decimalValue, decimalFromFloat);
|
|||
|
|
Assert.Equal<decimal>(decimalValue, decimalFromDecimal);
|
|||
|
|
Assert.Equal<decimal>(decimalValue, decimalFromString);
|
|||
|
|
|
|||
|
|
Log.Info("Casts to String");
|
|||
|
|
|
|||
|
|
string stringFromByte = dyn.Byte;
|
|||
|
|
string stringFromSByte = dyn.SByte;
|
|||
|
|
string stringFromShort = dyn.Int16;
|
|||
|
|
string stringFromUShort = dyn.UInt16;
|
|||
|
|
string stringFromInt = dyn.Int32;
|
|||
|
|
string stringFromUInt = dyn.UInt32;
|
|||
|
|
string stringFromLong = dyn.Int64;
|
|||
|
|
string stringFromULong = dyn.UInt64;
|
|||
|
|
string stringFromDouble = dyn.Double;
|
|||
|
|
string stringFromFloat = dyn.Single;
|
|||
|
|
string stringFromDecimal = dyn.Decimal;
|
|||
|
|
string stringFromString = dyn.String;
|
|||
|
|
|
|||
|
|
Assert.Equal(stringValue, stringFromByte);
|
|||
|
|
Assert.Equal(stringValue, stringFromSByte);
|
|||
|
|
Assert.Equal(stringValue, stringFromShort);
|
|||
|
|
Assert.Equal(stringValue, stringFromUShort);
|
|||
|
|
Assert.Equal(stringValue, stringFromInt);
|
|||
|
|
Assert.Equal(stringValue, stringFromUInt);
|
|||
|
|
Assert.Equal(stringValue, stringFromLong);
|
|||
|
|
Assert.Equal(stringValue, stringFromULong);
|
|||
|
|
Assert.Equal(stringValue, stringFromDouble);
|
|||
|
|
Assert.Equal(stringValue, stringFromFloat);
|
|||
|
|
Assert.Equal(stringValue, stringFromDecimal);
|
|||
|
|
Assert.Equal(stringValue, stringFromString);
|
|||
|
|
|
|||
|
|
Log.Info("Casts to Boolean");
|
|||
|
|
|
|||
|
|
bool bTrue = dyn.True;
|
|||
|
|
bool bFalse = dyn.False;
|
|||
|
|
Assert.True(bTrue);
|
|||
|
|
Assert.False(bFalse);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Test for creating a JsonValue from a deep-nested dynamic object.
|
|||
|
|
/// </summary>
|
|||
|
|
[Fact]
|
|||
|
|
public void CreateFromDeepNestedDynamic()
|
|||
|
|
{
|
|||
|
|
int count = 5000;
|
|||
|
|
string expected = "";
|
|||
|
|
|
|||
|
|
dynamic dyn = new TestDynamicObject();
|
|||
|
|
dynamic cur = dyn;
|
|||
|
|
|
|||
|
|
for (int i = 0; i < count; i++)
|
|||
|
|
{
|
|||
|
|
expected += "{\"" + i + "\":";
|
|||
|
|
cur[i.ToString()] = new TestDynamicObject();
|
|||
|
|
cur = cur[i.ToString()];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
expected += "{}";
|
|||
|
|
|
|||
|
|
for (int i = 0; i < count; i++)
|
|||
|
|
{
|
|||
|
|
expected += "}";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
JsonValue jv = JsonValueExtensions.CreateFrom(dyn);
|
|||
|
|
Assert.Equal(expected, jv.ToString());
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void ValidateResult<ResultType>(dynamic value, ResultType expectedResult)
|
|||
|
|
{
|
|||
|
|
Assert.IsAssignableFrom(typeof(ResultType), value);
|
|||
|
|
Assert.Equal<ResultType>(expectedResult, (ResultType)value);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Concrete DynamicObject class for testing purposes.
|
|||
|
|
/// </summary>
|
|||
|
|
internal class TestDynamicObject : DynamicObject
|
|||
|
|
{
|
|||
|
|
private IDictionary<string, object> _values = new Dictionary<string, object>();
|
|||
|
|
|
|||
|
|
public override IEnumerable<string> GetDynamicMemberNames()
|
|||
|
|
{
|
|||
|
|
return _values.Keys;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public override bool TrySetMember(SetMemberBinder binder, object value)
|
|||
|
|
{
|
|||
|
|
_values[binder.Name] = value;
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public override bool TryGetMember(GetMemberBinder binder, out object result)
|
|||
|
|
{
|
|||
|
|
return _values.TryGetValue(binder.Name, out result);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public override bool TrySetIndex(SetIndexBinder binder, object[] indexes, object value)
|
|||
|
|
{
|
|||
|
|
string key = indexes[0].ToString();
|
|||
|
|
|
|||
|
|
if (_values.ContainsKey(key))
|
|||
|
|
{
|
|||
|
|
_values[key] = value;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
_values.Add(key, value);
|
|||
|
|
}
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
|
|||
|
|
{
|
|||
|
|
string key = indexes[0].ToString();
|
|||
|
|
|
|||
|
|
if (_values.ContainsKey(key))
|
|||
|
|
{
|
|||
|
|
result = _values[key];
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
result = null;
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|