/test/System.Json.Test.Integration/JsonValueDynamicTests.cs
C# | 1098 lines | 920 code | 129 blank | 49 comment | 57 complexity | 7743a82938232fb2816ba85a25de9a57 MD5 | raw file
- 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];
-