/// <summary>${iServer2_SetLayerStatusResult_method_FromJson_D}</summary>
 /// <returns>${iServer2_SetLayerStatusResult_method_FromJson_return}</returns>
 /// <param name="jsonPrimitive">${iServer2_SetLayerStatusResult_method_FromJson_param_jsonObject}</param>
 public static SetLayerStatusResult FromJson(JsonPrimitive jsonPrimitive)
 {
     if (jsonPrimitive == null)
     {
         return null;
     }
     return new SetLayerStatusResult { LayersKey = jsonPrimitive };
 }
        /// <summary>${iServer2_RemoveThemesResult_method_FromJson_D}</summary>
        /// <returns>${iServer2_RemoveThemesResult_method_FromJson_return}</returns>
        /// <param name="jsonPrimitive">${iServer2_RemoveThemesResult_method_FromJson_param_jsonObject}</param>
        public static RemoveThemesResult FromJson(JsonPrimitive jsonPrimitive)
        {
            if (jsonPrimitive == null)
            {
                return null;
            }

            return new RemoveThemesResult { LayerKey = jsonPrimitive };
        }
 /// <summary>${IS6_SetLayerStatusResult_method_FromJson_D}</summary>
 /// <returns>${IS6_SetLayerStatusResult_method_FromJson_return}</returns>
 /// <param name="jsonObject">${IS6_SetLayerStatusResult_method_FromJson_param_jsonObject}</param>
 public static SetLayerStatusResult FromJson(JsonPrimitive jsonObject)
 {
     if (jsonObject == null)
     {
         return null;
     }
     SetLayerStatusResult result = new SetLayerStatusResult();
     result.LayersKey=(string)jsonObject;
     return result;
 }
        public void ValidJsonObjectDateTimeOffsetRoundTrip()
        {
            int seed = 1;
            Log.Info("Seed: {0}", seed);
            Random rndGen = new Random(seed);

            JsonPrimitive sourceJson = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfDateTimeOffset(rndGen));
            JsonPrimitive newJson = (JsonPrimitive)JsonValue.Parse(sourceJson.ToString());

            Assert.True(JsonValueVerifier.Compare(sourceJson, newJson));
        }
        public void ValidJsonObjectDateTimeOffsetRoundTrip()
        {
            int seed = 1;

            Log.Info("Seed: {0}", seed);
            Random rndGen = new Random(seed);

            JsonPrimitive sourceJson = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfDateTimeOffset(rndGen));
            JsonPrimitive newJson    = (JsonPrimitive)JsonValue.Parse(sourceJson.ToString());

            Assert.True(JsonValueVerifier.Compare(sourceJson, newJson));
        }
Example #6
0
        public void CastTests()
        {
            int value = 10;
            JsonValue target = new JsonPrimitive(value);

            int v1 = JsonValue.CastValue<int>(target);
            Assert.AreEqual<int>(value, v1);
            v1 = (int)target;
            Assert.AreEqual<int>(value, v1);

            long v2 = JsonValue.CastValue<long>(target);
            Assert.AreEqual<long>(value, v2);
            v2 = (long)target;
            Assert.AreEqual<long>(value, v2);

            string s = JsonValue.CastValue<string>(target);
            Assert.AreEqual<string>(value.ToString(), s);
            s = (string)target;
            Assert.AreEqual<string>(value.ToString(), s);

            object obj = JsonValue.CastValue<object>(target);
            Assert.AreEqual(target, obj);
            obj = (object)target;
            Assert.AreEqual(target, obj);

            object nill = JsonValue.CastValue<object>(null);
            Assert.IsNull(nill);

            dynamic dyn = target;
            JsonValue defaultJv = dyn.IamDefault;
            nill = JsonValue.CastValue<string>(defaultJv);
            Assert.IsNull(nill);
            nill = (string)defaultJv;
            Assert.IsNull(nill);

            obj = JsonValue.CastValue<object>(defaultJv);
            Assert.AreSame(defaultJv, obj);
            obj = (object)defaultJv;
            Assert.AreSame(defaultJv, obj);

            JsonValue jv = JsonValue.CastValue<JsonValue>(target);
            Assert.AreEqual<JsonValue>(target, jv);

            jv = JsonValue.CastValue<JsonValue>(defaultJv);
            Assert.AreEqual<JsonValue>(defaultJv, jv);

            jv = JsonValue.CastValue<JsonPrimitive>(target);
            Assert.AreEqual<JsonValue>(target, jv);

            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { int i = JsonValue.CastValue<int>(null); });
            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { int i = JsonValue.CastValue<int>(defaultJv); });
            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { int i = JsonValue.CastValue<char>(target); });
        }
        private void CheckValues(object[] values, JsonType expectedType)
        {
            JsonPrimitive target;
            bool          success;

            foreach (object value in values)
            {
                success = JsonPrimitive.TryCreate(value, out target);
                Assert.True(success);
                Assert.NotNull(target);
                Assert.Equal(expectedType, target.JsonType);
            }
        }
        /// <summary>${iServer2_ThemeResult_method_FromJson_D}</summary>
        /// <returns>${iServer2_ThemeResult_method_FromJson_return}</returns>
        /// <param name="jsonPrimitive">${iServer2_ThemeResult_method_FromJson_param_jsonObject}</param>
        public static ThemeResult FromJson(JsonPrimitive jsonPrimitive)
        {
            if (jsonPrimitive == null)
            {
                return null;
            }

            string str = jsonPrimitive;
            ThemeResult result = new ThemeResult();
            result.Name = str.Substring(0, str.IndexOf(","));
            result.Key = str.Substring(str.IndexOf(",") + 1, str.Length - str.IndexOf(",") - 1);
            return result;
        }
        /// <summary>${IS6_ThemeResult_method_FromJson_D}</summary>
        /// <returns>${IS6_ThemeResult_method_FromJson_return}</returns>
        /// <param name="jsonPrimitive">${IS6_ThemeResult_method_FromJson_param_jsonObject}</param>
        public static ThemeResult FromJson(JsonPrimitive jsonPrimitive)
        {
            if (jsonPrimitive == null)
            {
                return null;
            }

            ThemeResult result = new ThemeResult();

            result.LayerKey = jsonPrimitive;

            return result;
        }
        public void ValueTest()
        {
            object[] values =
            {
                AnyInstance.AnyInt, AnyInstance.AnyString, AnyInstance.AnyGuid, AnyInstance.AnyDecimal, AnyInstance.AnyBool, AnyInstance.AnyDateTime
            };

            foreach (object value in values)
            {
                JsonPrimitive jp;
                bool          success = JsonPrimitive.TryCreate(value, out jp);
                Assert.True(success);
                Assert.Equal(value, jp.Value);
            }
        }
        public void ReadAsTest()
        {
            JsonValue target = new JsonPrimitive(AnyInstance.AnyInt);

            Assert.Equal(AnyInstance.AnyInt.ToString(CultureInfo.InvariantCulture), target.ReadAs(typeof(string)));
            Assert.Equal(AnyInstance.AnyInt.ToString(CultureInfo.InvariantCulture), target.ReadAs <string>());
            object value;
            double dblValue;

            Assert.True(target.TryReadAs(typeof(double), out value));
            Assert.True(target.TryReadAs <double>(out dblValue));
            Assert.Equal(Convert.ToDouble(AnyInstance.AnyInt, CultureInfo.InvariantCulture), (double)value);
            Assert.Equal(Convert.ToDouble(AnyInstance.AnyInt, CultureInfo.InvariantCulture), dblValue);
            Assert.False(target.TryReadAs(typeof(Guid), out value), "TryReadAs should have failed to read a double as a Guid");
            Assert.Null(value);
        }
        public void NonNumberToNumberConversionTest()
        {
            Assert.Equal(1, new JsonPrimitive('1').ReadAs <int>());
            Assert.Equal <byte>(AnyInstance.AnyByte, new JsonPrimitive(AnyInstance.AnyByte.ToString(CultureInfo.InvariantCulture)).ReadAs <byte>());
            Assert.Equal <sbyte>(AnyInstance.AnySByte, (sbyte)(new JsonPrimitive(AnyInstance.AnySByte.ToString(CultureInfo.InvariantCulture))));
            Assert.Equal <short>(AnyInstance.AnyShort, (short)(new JsonPrimitive(AnyInstance.AnyShort.ToString(CultureInfo.InvariantCulture))));
            Assert.Equal <ushort>(AnyInstance.AnyUShort, new JsonPrimitive(AnyInstance.AnyUShort.ToString(CultureInfo.InvariantCulture)).ReadAs <ushort>());
            Assert.Equal <int>(AnyInstance.AnyInt, new JsonPrimitive(AnyInstance.AnyInt.ToString(CultureInfo.InvariantCulture)).ReadAs <int>());
            Assert.Equal <uint>(AnyInstance.AnyUInt, (uint)(new JsonPrimitive(AnyInstance.AnyUInt.ToString(CultureInfo.InvariantCulture))));
            Assert.Equal <long>(AnyInstance.AnyLong, (long)(new JsonPrimitive(AnyInstance.AnyLong.ToString(CultureInfo.InvariantCulture))));
            Assert.Equal <ulong>(AnyInstance.AnyULong, new JsonPrimitive(AnyInstance.AnyULong.ToString(CultureInfo.InvariantCulture)).ReadAs <ulong>());

            Assert.Equal <decimal>(AnyInstance.AnyDecimal, (decimal)(new JsonPrimitive(AnyInstance.AnyDecimal.ToString(CultureInfo.InvariantCulture))));
            Assert.Equal <float>(AnyInstance.AnyFloat, new JsonPrimitive(AnyInstance.AnyFloat.ToString(CultureInfo.InvariantCulture)).ReadAs <float>());
            Assert.Equal <double>(AnyInstance.AnyDouble, (double)(new JsonPrimitive(AnyInstance.AnyDouble.ToString(CultureInfo.InvariantCulture))));

            Assert.Equal <byte>(Convert.ToByte(1.23, CultureInfo.InvariantCulture), new JsonPrimitive("1.23").ReadAs <byte>());
            Assert.Equal <int>(Convert.ToInt32(12345.6789, CultureInfo.InvariantCulture), new JsonPrimitive("12345.6789").ReadAs <int>());
            Assert.Equal <short>(Convert.ToInt16(1.23e2), (short)new JsonPrimitive("1.23e2"));
            Assert.Equal <float>(Convert.ToSingle(1.23e40), (float)new JsonPrimitive("1.23e40"));
            Assert.Equal <float>(Convert.ToSingle(1.23e-38), (float)new JsonPrimitive("1.23e-38"));

            ExceptionHelper.Throws <InvalidCastException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyBool).ReadAs <sbyte>(); });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyBool).ReadAs <short>(); });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyBool).ReadAs <uint>(); });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyBool).ReadAs <long>(); });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyBool).ReadAs <double>(); });

            ExceptionHelper.Throws <FormatException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyUri).ReadAs <int>(); });
            ExceptionHelper.Throws <FormatException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyDateTime).ReadAs <float>(); });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var n = (decimal)(new JsonPrimitive('c')); });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var n = (byte)(new JsonPrimitive("0xFF")); });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var n = (sbyte)(new JsonPrimitive(AnyInstance.AnyDateTimeOffset)); });
            ExceptionHelper.Throws <FormatException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyUri).ReadAs <uint>(); });
            ExceptionHelper.Throws <FormatException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyDateTime).ReadAs <double>(); });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var n = (long)(new JsonPrimitive('c')); });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var n = (ulong)(new JsonPrimitive("0xFF")); });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var n = (short)(new JsonPrimitive(AnyInstance.AnyDateTimeOffset)); });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var n = (ushort)(new JsonPrimitive('c')); });

            ExceptionHelper.Throws <OverflowException>(delegate { int i = (int)new JsonPrimitive((1L << 32).ToString(CultureInfo.InvariantCulture)); });
            ExceptionHelper.Throws <OverflowException>(delegate { byte b = (byte)new JsonPrimitive("-1"); });
        }
        public void TryCreateInvalidTest()
        {
            bool          success;
            JsonPrimitive target;

            object[] values =
            {
                AnyInstance.AnyJsonArray, AnyInstance.AnyJsonObject,    AnyInstance.AnyJsonPrimitive,
                null,                     AnyInstance.DefaultJsonValue, AnyInstance.AnyDynamic,      AnyInstance.AnyAddress,
                AnyInstance.AnyPerson
            };

            foreach (object value in values)
            {
                success = JsonPrimitive.TryCreate(value, out target);
                Assert.False(success);
                Assert.Null(target);
            }
        }
        public void CastingTests()
        {
            JsonValue target = new JsonPrimitive(AnyInstance.AnyInt);

            Assert.Equal(AnyInstance.AnyInt.ToString(CultureInfo.InvariantCulture), (string)target);
            Assert.Equal(Convert.ToDouble(AnyInstance.AnyInt, CultureInfo.InvariantCulture), (double)target);

            Assert.Equal(AnyInstance.AnyString, (string)(JsonValue)AnyInstance.AnyString);
            Assert.Equal(AnyInstance.AnyChar, (char)(JsonValue)AnyInstance.AnyChar);
            Assert.Equal(AnyInstance.AnyUri, (Uri)(JsonValue)AnyInstance.AnyUri);
            Assert.Equal(AnyInstance.AnyGuid, (Guid)(JsonValue)AnyInstance.AnyGuid);
            Assert.Equal(AnyInstance.AnyDateTime, (DateTime)(JsonValue)AnyInstance.AnyDateTime);
            Assert.Equal(AnyInstance.AnyDateTimeOffset, (DateTimeOffset)(JsonValue)AnyInstance.AnyDateTimeOffset);
            Assert.Equal(AnyInstance.AnyBool, (bool)(JsonValue)AnyInstance.AnyBool);
            Assert.Equal(AnyInstance.AnyByte, (byte)(JsonValue)AnyInstance.AnyByte);
            Assert.Equal(AnyInstance.AnyShort, (short)(JsonValue)AnyInstance.AnyShort);
            Assert.Equal(AnyInstance.AnyInt, (int)(JsonValue)AnyInstance.AnyInt);
            Assert.Equal(AnyInstance.AnyLong, (long)(JsonValue)AnyInstance.AnyLong);
            Assert.Equal(AnyInstance.AnySByte, (sbyte)(JsonValue)AnyInstance.AnySByte);
            Assert.Equal(AnyInstance.AnyUShort, (ushort)(JsonValue)AnyInstance.AnyUShort);
            Assert.Equal(AnyInstance.AnyUInt, (uint)(JsonValue)AnyInstance.AnyUInt);
            Assert.Equal(AnyInstance.AnyULong, (ulong)(JsonValue)AnyInstance.AnyULong);
            Assert.Equal(AnyInstance.AnyDecimal, (decimal)(JsonValue)AnyInstance.AnyDecimal);
            Assert.Equal(AnyInstance.AnyFloat, (float)(JsonValue)AnyInstance.AnyFloat);
            Assert.Equal(AnyInstance.AnyDouble, (double)(JsonValue)AnyInstance.AnyDouble);

            Uri    uri = null;
            string str = null;

            JsonValue jv = uri;

            Assert.Null(jv);
            uri = (Uri)jv;
            Assert.Null(uri);

            jv = str;
            Assert.Null(jv);
            str = (string)jv;
            Assert.Null(str);

            ExceptionHelper.Throws <InvalidCastException>(delegate { var s = (string)AnyInstance.AnyJsonArray; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var s = (string)AnyInstance.AnyJsonObject; });
        }
Example #15
0
        public void CastingTests()
        {
            JsonValue target = new JsonPrimitive(AnyInstance.AnyInt);

            Assert.AreEqual(AnyInstance.AnyInt.ToString(CultureInfo.InvariantCulture), (string)target);
            Assert.AreEqual(Convert.ToDouble(AnyInstance.AnyInt, CultureInfo.InvariantCulture), (double)target);

            Assert.AreEqual(AnyInstance.AnyString, (string)(JsonValue)AnyInstance.AnyString);
            Assert.AreEqual(AnyInstance.AnyChar, (char)(JsonValue)AnyInstance.AnyChar);
            Assert.AreEqual(AnyInstance.AnyUri, (Uri)(JsonValue)AnyInstance.AnyUri);
            Assert.AreEqual(AnyInstance.AnyGuid, (Guid)(JsonValue)AnyInstance.AnyGuid);
            Assert.AreEqual(AnyInstance.AnyDateTime, (DateTime)(JsonValue)AnyInstance.AnyDateTime);
            Assert.AreEqual(AnyInstance.AnyDateTimeOffset, (DateTimeOffset)(JsonValue)AnyInstance.AnyDateTimeOffset);
            Assert.AreEqual(AnyInstance.AnyBool, (bool)(JsonValue)AnyInstance.AnyBool);
            Assert.AreEqual(AnyInstance.AnyByte, (byte)(JsonValue)AnyInstance.AnyByte);
            Assert.AreEqual(AnyInstance.AnyShort, (short)(JsonValue)AnyInstance.AnyShort);
            Assert.AreEqual(AnyInstance.AnyInt, (int)(JsonValue)AnyInstance.AnyInt);
            Assert.AreEqual(AnyInstance.AnyLong, (long)(JsonValue)AnyInstance.AnyLong);
            Assert.AreEqual(AnyInstance.AnySByte, (sbyte)(JsonValue)AnyInstance.AnySByte);
            Assert.AreEqual(AnyInstance.AnyUShort, (ushort)(JsonValue)AnyInstance.AnyUShort);
            Assert.AreEqual(AnyInstance.AnyUInt, (uint)(JsonValue)AnyInstance.AnyUInt);
            Assert.AreEqual(AnyInstance.AnyULong, (ulong)(JsonValue)AnyInstance.AnyULong);
            Assert.AreEqual(AnyInstance.AnyDecimal, (decimal)(JsonValue)AnyInstance.AnyDecimal);
            Assert.AreEqual(AnyInstance.AnyFloat, (float)(JsonValue)AnyInstance.AnyFloat);
            Assert.AreEqual(AnyInstance.AnyDouble, (double)(JsonValue)AnyInstance.AnyDouble);

            Uri uri = null;
            string str = null;

            JsonValue jv = uri;
            Assert.IsNull(jv);
            uri = (Uri)jv;
            Assert.IsNull(uri);

            jv = str;
            Assert.IsNull(jv);
            str = (string)jv;
            Assert.IsNull(str);

            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { var s = (string)AnyInstance.AnyJsonArray; });
            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { var s = (string)AnyInstance.AnyJsonObject; });
        }
Example #16
0
        // the input JsonPrimitive DateTime format is "\/Date(24735422733034-0700)\/" or "\/Date(24735422733034)\/"
        // the only thing useful for us is the UTC ticks "24735422733034"
        // everything after - if present - is just an optional offset between the local time and UTC
        private static string GetUTCTicks(JsonPrimitive jprim)
        {
            string retValue = String.Empty;

            string origStr    = jprim.ToString();
            int    startIndex = origStr.IndexOf("Date(") + 5;
            int    endIndex   = origStr.IndexOf('-', startIndex + 1); // the UTC ticks can start with a '-' sign (dates prior to 1970/01/01)

            // if the optional offset is present in the data format, we want to take only the UTC ticks
            if (startIndex < endIndex)
            {
                retValue = origStr.Substring(startIndex, endIndex - startIndex);
            }
            else
            {
                // otherwise we assume the time format is without the oiptional offset, or unexpected, and use the whole string for comparison.
                retValue = origStr;
            }

            return(retValue);
        }
        public void TestInvalidOperations()
        {
            JsonArray ja = new JsonArray {
                1, null, "hello"
            };
            JsonObject jo = new JsonObject
            {
                { "first", 1 },
                { "second", null },
                { "third", "hello" },
            };
            JsonPrimitive jp = new JsonPrimitive("hello");

            Assert.Throws <InvalidOperationException>(() => "jp[\"hello\"] should fail: " + jp["hello"].ToString());

            Assert.Throws <InvalidOperationException>(() => "ja[\"hello\"] should fail: " + ja["hello"].ToString());


            Assert.Throws <InvalidOperationException>(() => jp["hello"] = "This shouldn't happen");


            Assert.Throws <InvalidOperationException>(() => ja["hello"] = "This shouldn't happen");

            Assert.Throws <InvalidOperationException>(() => ("jp[1] should fail: " + jp[1].ToString()));

            Assert.Throws <InvalidOperationException>(() => "jo[0] should fail: " + jo[1].ToString());

            Assert.Throws <InvalidOperationException>(() => jp[0] = "This shouldn't happen");

            Assert.Throws <InvalidOperationException>(() => jo[0] = "This shouldn't happen");

            Assert.Throws <InvalidCastException>(() => "(DateTimeOffset)jp[\"hello\"] should fail: " + (DateTimeOffset)jp);

            Assert.Throws <InvalidCastException>(() => ("(Char)jp[\"hello\"] should fail: " + (char)jp));

            Assert.Throws <InvalidCastException>(() =>
            {
                short jprim = (short)new JsonPrimitive(false);
            });
        }
        public void NonNumberToStringConversionTest()
        {
            Dictionary <string, JsonPrimitive> allValues = new Dictionary <string, JsonPrimitive>
            {
                { new string(AnyInstance.AnyChar, 1), new JsonPrimitive(AnyInstance.AnyChar) },
                { AnyInstance.AnyBool.ToString(CultureInfo.InvariantCulture).ToLowerInvariant(), new JsonPrimitive(AnyInstance.AnyBool) },
                { AnyInstance.AnyGuid.ToString("D", CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyGuid) },
                { AnyInstance.AnyDateTime.ToString(DateTimeFormat, CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyDateTime) },
                { AnyInstance.AnyDateTimeOffset.ToString(DateTimeFormat, CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyDateTimeOffset) },
            };

            foreach (char escapedChar in "\r\n\t\u0000\uffff\u001f\\\"")
            {
                allValues.Add(new string(escapedChar, 1), new JsonPrimitive(escapedChar));
            }

            foreach (string stringRepresentation in allValues.Keys)
            {
                JsonPrimitive jp = allValues[stringRepresentation];
                Assert.Equal(stringRepresentation, (string)jp);
                Assert.Equal(stringRepresentation, jp.ReadAs <string>());
            }
        }
        public void NumberToStringConverstionTest()
        {
            Dictionary <string, JsonPrimitive> allNumbers = new Dictionary <string, JsonPrimitive>
            {
                { AnyInstance.AnyByte.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyByte) },
                { AnyInstance.AnySByte.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnySByte) },
                { AnyInstance.AnyShort.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyShort) },
                { AnyInstance.AnyUShort.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyUShort) },
                { AnyInstance.AnyInt.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyInt) },
                { AnyInstance.AnyUInt.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyUInt) },
                { AnyInstance.AnyLong.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyLong) },
                { AnyInstance.AnyULong.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyULong) },
                { AnyInstance.AnyDecimal.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyDecimal) },
                { AnyInstance.AnyDouble.ToString("R", CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyDouble) },
                { AnyInstance.AnyFloat.ToString("R", CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyFloat) },
            };

            foreach (string stringRepresentation in allNumbers.Keys)
            {
                JsonPrimitive jp = allNumbers[stringRepresentation];
                Assert.Equal(stringRepresentation, (string)jp);
                Assert.Equal(stringRepresentation, jp.ReadAs <string>());
            }
        }
        private void DoRoundTripCasting(JsonValue jo, Type type)
        {
            bool result = false;

            // Casting
            if (jo.JsonType == JsonType.String)
            {
                JsonValue jstr = (string)jo;
                if (type == typeof(DateTime))
                {
                    Log.Info("{0} Value:{1}", type.Name, ((DateTime)jstr).ToString(DateTimeFormatInfo.InvariantInfo));
                }
                else if (type == typeof(DateTimeOffset))
                {
                    Log.Info("{0} Value:{1}", type.Name, ((DateTimeOffset)jstr).ToString(DateTimeFormatInfo.InvariantInfo));
                }
                else if (type == typeof(Guid))
                {
                    Log.Info("{0} Value:{1}", type.Name, (Guid)jstr);
                }
                else if (type == typeof(char))
                {
                    Log.Info("{0} Value:{1}", type.Name, (char)jstr);
                }
                else if (type == typeof(Uri))
                {
                    Log.Info("{0} Value:{1}", type.Name, ((Uri)jstr).AbsoluteUri);
                }
                else
                {
                    Log.Info("{0} Value:{1}", type.Name, (string)jstr);
                }

                if (jo.ToString() == jstr.ToString())
                {
                    result = true;
                }
            }
            else if (jo.JsonType == JsonType.Object)
            {
                JsonObject jobj = new JsonObject((JsonObject)jo);

                if (jo.ToString() == jobj.ToString())
                {
                    result = true;
                }
            }
            else if (jo.JsonType == JsonType.Number)
            {
                JsonPrimitive jprim = (JsonPrimitive)jo;
                Log.Info("{0} Value:{1}", type.Name, jprim);

                if (jo.ToString() == jprim.ToString())
                {
                    result = true;
                }
            }
            else if (jo.JsonType == JsonType.Boolean)
            {
                JsonPrimitive jprim = (JsonPrimitive)jo;
                Log.Info("{0} Value:{1}", type.Name, (bool)jprim);

                if (jo.ToString() == jprim.ToString())
                {
                    result = true;
                }
            }

            Assert.True(result);
        }
        private bool TestPrimitiveType(string typeName)
        {
            bool retValue    = true;
            bool specialCase = false;

            int seed = 1;

            Log.Info("Seed: {0}", seed);
            Random rndGen = new Random(seed);

            JsonPrimitive sourceJson = null;
            JsonPrimitive sourceJson2;
            object        tempValue = null;

            switch (typeName.ToLower())
            {
            case "boolean":
                tempValue   = PrimitiveCreator.CreateInstanceOfBoolean(rndGen);
                sourceJson  = (JsonPrimitive)JsonValue.Parse(tempValue.ToString().ToLower());
                sourceJson2 = new JsonPrimitive((bool)tempValue);
                break;

            case "byte":
                tempValue   = PrimitiveCreator.CreateInstanceOfByte(rndGen);
                sourceJson  = (JsonPrimitive)JsonValue.Parse(tempValue.ToString());
                sourceJson2 = new JsonPrimitive((byte)tempValue);
                break;

            case "char":
                sourceJson2 = new JsonPrimitive((char)PrimitiveCreator.CreateInstanceOfChar(rndGen));
                specialCase = true;
                break;

            case "datetime":
                tempValue   = PrimitiveCreator.CreateInstanceOfDateTime(rndGen);
                sourceJson2 = new JsonPrimitive((DateTime)tempValue);
                sourceJson  = (JsonPrimitive)JsonValue.Parse(sourceJson2.ToString());
                break;

            case "decimal":
                tempValue   = PrimitiveCreator.CreateInstanceOfDecimal(rndGen);
                sourceJson  = (JsonPrimitive)JsonValue.Parse(((decimal)tempValue).ToString(NumberFormatInfo.InvariantInfo));
                sourceJson2 = new JsonPrimitive((decimal)tempValue);
                break;

            case "double":
                double tempDouble = PrimitiveCreator.CreateInstanceOfDouble(rndGen);
                sourceJson  = (JsonPrimitive)JsonValue.Parse(tempDouble.ToString("R", NumberFormatInfo.InvariantInfo));
                sourceJson2 = new JsonPrimitive(tempDouble);
                break;

            case "guid":
                sourceJson2 = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfGuid(rndGen));
                specialCase = true;
                break;

            case "int16":
                tempValue   = PrimitiveCreator.CreateInstanceOfInt16(rndGen);
                sourceJson  = (JsonPrimitive)JsonValue.Parse(tempValue.ToString());
                sourceJson2 = new JsonPrimitive((short)tempValue);
                break;

            case "int32":
                tempValue   = PrimitiveCreator.CreateInstanceOfInt32(rndGen);
                sourceJson  = (JsonPrimitive)JsonValue.Parse(tempValue.ToString());
                sourceJson2 = new JsonPrimitive((int)tempValue);
                break;

            case "int64":
                tempValue   = PrimitiveCreator.CreateInstanceOfInt64(rndGen);
                sourceJson  = (JsonPrimitive)JsonValue.Parse(tempValue.ToString());
                sourceJson2 = new JsonPrimitive((long)tempValue);
                break;

            case "sbyte":
                tempValue   = PrimitiveCreator.CreateInstanceOfSByte(rndGen);
                sourceJson  = (JsonPrimitive)JsonValue.Parse(tempValue.ToString());
                sourceJson2 = new JsonPrimitive((sbyte)tempValue);
                break;

            case "single":
                float fltValue = PrimitiveCreator.CreateInstanceOfSingle(rndGen);
                sourceJson  = (JsonPrimitive)JsonValue.Parse(fltValue.ToString("R", NumberFormatInfo.InvariantInfo));
                sourceJson2 = new JsonPrimitive(fltValue);
                break;

            case "string":
                do
                {
                    tempValue = PrimitiveCreator.CreateInstanceOfString(rndGen);
                } while (tempValue == null);

                sourceJson2 = new JsonPrimitive((string)tempValue);
                sourceJson  = (JsonPrimitive)JsonValue.Parse(sourceJson2.ToString());
                break;

            case "uint16":
                tempValue   = PrimitiveCreator.CreateInstanceOfUInt16(rndGen);
                sourceJson  = (JsonPrimitive)JsonValue.Parse(tempValue.ToString());
                sourceJson2 = new JsonPrimitive((ushort)tempValue);
                break;

            case "uint32":
                tempValue   = PrimitiveCreator.CreateInstanceOfUInt32(rndGen);
                sourceJson  = (JsonPrimitive)JsonValue.Parse(tempValue.ToString());
                sourceJson2 = new JsonPrimitive((uint)tempValue);
                break;

            case "uint64":
                tempValue   = PrimitiveCreator.CreateInstanceOfUInt64(rndGen);
                sourceJson  = (JsonPrimitive)JsonValue.Parse(tempValue.ToString());
                sourceJson2 = new JsonPrimitive((ulong)tempValue);
                break;

            case "uri":
                Uri uri = null;
                do
                {
                    try
                    {
                        uri = PrimitiveCreator.CreateInstanceOfUri(rndGen);
                    }
                    catch (UriFormatException)
                    {
                    }
                } while (uri == null);

                sourceJson2 = new JsonPrimitive(uri);
                specialCase = true;
                break;

            case "null":
                sourceJson  = (JsonPrimitive)JsonValue.Parse("null");
                sourceJson2 = null;
                break;

            default:
                sourceJson  = null;
                sourceJson2 = null;
                break;
            }

            if (!specialCase)
            {
                // comparison between two constructors
                if (!JsonValueVerifier.Compare(sourceJson, sourceJson2))
                {
                    Log.Info("(JsonPrimitive)JsonValue.Parse(string) failed to match the results from default JsonPrimitive(obj)constructor for type {0}", typeName);
                    retValue = false;
                }

                if (sourceJson != null)
                {
                    // test JsonValue.Load(TextReader)
                    JsonPrimitive newJson = null;
                    using (StringReader sr = new StringReader(sourceJson.ToString()))
                    {
                        newJson = (JsonPrimitive)JsonValue.Load(sr);
                    }

                    if (!JsonValueVerifier.Compare(sourceJson, newJson))
                    {
                        Log.Info("JsonValue.Load(TextReader) failed to function properly for type {0}", typeName);
                        retValue = false;
                    }

                    // test JsonValue.Load(Stream) is located in the JObjectFromGenoTypeLib test case

                    // test JsonValue.Parse(string)
                    newJson = null;
                    newJson = (JsonPrimitive)JsonValue.Parse(sourceJson.ToString());
                    if (!JsonValueVerifier.Compare(sourceJson, newJson))
                    {
                        Log.Info("JsonValue.Parse(string) failed to function properly for type {0}", typeName);
                        retValue = false;
                    }
                }
            }
            else
            {
                // test JsonValue.Load(TextReader)
                JsonPrimitive newJson2 = null;
                using (StringReader sr = new StringReader(sourceJson2.ToString()))
                {
                    newJson2 = (JsonPrimitive)JsonValue.Load(sr);
                }

                if (!JsonValueVerifier.Compare(sourceJson2, newJson2))
                {
                    Log.Info("JsonValue.Load(TextReader) failed to function properly for type {0}", typeName);
                    retValue = false;
                }

                // test JsonValue.Load(Stream) is located in the JObjectFromGenoTypeLib test case

                // test JsonValue.Parse(string)
                newJson2 = null;
                newJson2 = (JsonPrimitive)JsonValue.Parse(sourceJson2.ToString());
                if (!JsonValueVerifier.Compare(sourceJson2, newJson2))
                {
                    Log.Info("JsonValue.Parse(string) failed to function properly for type {0}", typeName);
                    retValue = false;
                }
            }

            return(retValue);
        }
Example #22
0
 private static bool CompareJsonPrimitiveTypes(JsonPrimitive objA, JsonPrimitive objB)
 {
     try
     {
         if (objA.ToString() != objB.ToString())
         {
             // Special case due to daylight saving hours change: every March on the morning of the third Sunday, we adjust the time
             // from 2am to 3am straight, so for that one hour 2:13am = 3:15am.  We must result to the UTC ticks to verify the actual
             // time is always the same, regardless of the loc/glob setup on the machine
             if (objA.ToString().StartsWith("\"\\/Date(") && objA.ToString().EndsWith(")\\/\""))
             {
                 return GetUTCTicks(objA) == GetUTCTicks(objB);
             }
             else
             {
                 Log.Info("JsonValueVerifier (JsonPrimitiveTypes) Error: objA = " + objA.ToString());
                 Log.Info("JsonValueVerifier (JsonPrimitiveTypes) Error: objB = " + objB.ToString());
                 return false;
             }
         }
         else
         {
             return true;
         }
     }
     catch (Exception e)
     {
         Log.Info("JsonValueVerifier (JsonPrimitiveTypes) Error: An Exception was thrown: " + e);
         return false;
     }
 }
        public static JsonValue JXMLToJsonValue(XmlDictionaryReader jsonReader)
        {
            if (jsonReader == null)
            {
                throw new ArgumentNullException("jsonReader");
            }

            const string      RootObjectName = "RootObject";
            Stack <JsonValue> jsonStack      = new Stack <JsonValue>();
            string            nodeType       = null;
            bool isEmptyElement = false;

            JsonValue parent = new JsonObject();

            jsonStack.Push(parent);
            string currentName = RootObjectName;

            try
            {
                MoveToRootNode(jsonReader);

                while (jsonStack.Count > 0 && jsonReader.NodeType != XmlNodeType.None)
                {
                    if (parent is JsonObject && currentName == null)
                    {
                        currentName = GetMemberName(jsonReader);
                    }

                    nodeType = jsonReader.GetAttribute(TypeAttributeName) ?? StringAttributeValue;

                    if (parent is JsonArray)
                    {
                        // For arrays, the element name has to be "item"
                        if (jsonReader.Name != ItemElementName)
                        {
                            throw new FormatException(Properties.Resources.IncorrectJsonFormat);
                        }
                    }

                    switch (nodeType)
                    {
                    case NullAttributeValue:
                    case BooleanAttributeValue:
                    case StringAttributeValue:
                    case NumberAttributeValue:
                        JsonPrimitive jsonPrimitive = ReadPrimitive(nodeType, jsonReader);
                        InsertJsonValue(jsonStack, ref parent, ref currentName, jsonPrimitive, true);
                        break;

                    case ArrayAttributeValue:
                        JsonArray jsonArray = CreateJsonArray(jsonReader, ref isEmptyElement);
                        InsertJsonValue(jsonStack, ref parent, ref currentName, jsonArray, isEmptyElement);
                        break;

                    case ObjectAttributeValue:
                        JsonObject jsonObject = CreateObjectWithTypeHint(jsonReader, ref isEmptyElement);
                        InsertJsonValue(jsonStack, ref parent, ref currentName, jsonObject, isEmptyElement);
                        break;

                    default:
                        throw new FormatException(Properties.Resources.IncorrectJsonFormat);
                    }

                    while (jsonReader.NodeType == XmlNodeType.EndElement && jsonStack.Count > 0)
                    {
                        jsonReader.Read();
                        SkipWhitespace(jsonReader);
                        jsonStack.Pop();
                        if (jsonStack.Count > 0)
                        {
                            parent = jsonStack.Peek();
                        }
                    }
                }
            }
            catch (XmlException xmlException)
            {
                throw new FormatException(Properties.Resources.IncorrectJsonFormat, xmlException);
            }

            if (jsonStack.Count != 1)
            {
                throw new FormatException(Properties.Resources.IncorrectJsonFormat);
            }

            return(parent[RootObjectName]);
        }
        private bool TestPrimitiveType(string typeName)
        {
            bool retValue = true;
            bool specialCase = false;

            int seed = 1;
            Log.Info("Seed: {0}", seed);
            Random rndGen = new Random(seed);

            JsonPrimitive sourceJson = null;
            JsonPrimitive sourceJson2;
            object tempValue = null;
            switch (typeName.ToLower())
            {
                case "boolean":
                    tempValue = PrimitiveCreator.CreateInstanceOfBoolean(rndGen);
                    sourceJson = (JsonPrimitive)JsonValue.Parse(tempValue.ToString().ToLower());
                    sourceJson2 = new JsonPrimitive((bool)tempValue);
                    break;
                case "byte":
                    tempValue = PrimitiveCreator.CreateInstanceOfByte(rndGen);
                    sourceJson = (JsonPrimitive)JsonValue.Parse(tempValue.ToString());
                    sourceJson2 = new JsonPrimitive((byte)tempValue);
                    break;
                case "char":
                    sourceJson2 = new JsonPrimitive((char)PrimitiveCreator.CreateInstanceOfChar(rndGen));
                    specialCase = true;
                    break;
                case "datetime":
                    tempValue = PrimitiveCreator.CreateInstanceOfDateTime(rndGen);
                    sourceJson2 = new JsonPrimitive((DateTime)tempValue);
                    sourceJson = (JsonPrimitive)JsonValue.Parse(sourceJson2.ToString());
                    break;
                case "decimal":
                    tempValue = PrimitiveCreator.CreateInstanceOfDecimal(rndGen);
                    sourceJson = (JsonPrimitive)JsonValue.Parse(((decimal)tempValue).ToString(NumberFormatInfo.InvariantInfo));
                    sourceJson2 = new JsonPrimitive((decimal)tempValue);
                    break;
                case "double":
                    double tempDouble = PrimitiveCreator.CreateInstanceOfDouble(rndGen);
                    sourceJson = (JsonPrimitive)JsonValue.Parse(tempDouble.ToString("R", NumberFormatInfo.InvariantInfo));
                    sourceJson2 = new JsonPrimitive(tempDouble);
                    break;
                case "guid":
                    sourceJson2 = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfGuid(rndGen));
                    specialCase = true;
                    break;
                case "int16":
                    tempValue = PrimitiveCreator.CreateInstanceOfInt16(rndGen);
                    sourceJson = (JsonPrimitive)JsonValue.Parse(tempValue.ToString());
                    sourceJson2 = new JsonPrimitive((short)tempValue);
                    break;
                case "int32":
                    tempValue = PrimitiveCreator.CreateInstanceOfInt32(rndGen);
                    sourceJson = (JsonPrimitive)JsonValue.Parse(tempValue.ToString());
                    sourceJson2 = new JsonPrimitive((int)tempValue);
                    break;
                case "int64":
                    tempValue = PrimitiveCreator.CreateInstanceOfInt64(rndGen);
                    sourceJson = (JsonPrimitive)JsonValue.Parse(tempValue.ToString());
                    sourceJson2 = new JsonPrimitive((long)tempValue);
                    break;
                case "sbyte":
                    tempValue = PrimitiveCreator.CreateInstanceOfSByte(rndGen);
                    sourceJson = (JsonPrimitive)JsonValue.Parse(tempValue.ToString());
                    sourceJson2 = new JsonPrimitive((sbyte)tempValue);
                    break;
                case "single":
                    float fltValue = PrimitiveCreator.CreateInstanceOfSingle(rndGen);
                    sourceJson = (JsonPrimitive)JsonValue.Parse(fltValue.ToString("R", NumberFormatInfo.InvariantInfo));
                    sourceJson2 = new JsonPrimitive(fltValue);
                    break;
                case "string":
                    do
                    {
                        tempValue = PrimitiveCreator.CreateInstanceOfString(rndGen);
                    } while (tempValue == null);

                    sourceJson2 = new JsonPrimitive((string)tempValue);
                    sourceJson = (JsonPrimitive)JsonValue.Parse(sourceJson2.ToString());
                    break;
                case "uint16":
                    tempValue = PrimitiveCreator.CreateInstanceOfUInt16(rndGen);
                    sourceJson = (JsonPrimitive)JsonValue.Parse(tempValue.ToString());
                    sourceJson2 = new JsonPrimitive((ushort)tempValue);
                    break;
                case "uint32":
                    tempValue = PrimitiveCreator.CreateInstanceOfUInt32(rndGen);
                    sourceJson = (JsonPrimitive)JsonValue.Parse(tempValue.ToString());
                    sourceJson2 = new JsonPrimitive((uint)tempValue);
                    break;
                case "uint64":
                    tempValue = PrimitiveCreator.CreateInstanceOfUInt64(rndGen);
                    sourceJson = (JsonPrimitive)JsonValue.Parse(tempValue.ToString());
                    sourceJson2 = new JsonPrimitive((ulong)tempValue);
                    break;
                case "uri":
                    Uri uri = null;
                    do
                    {
                        try
                        {
                            uri = PrimitiveCreator.CreateInstanceOfUri(rndGen);
                        }
                        catch (UriFormatException)
                        {
                        }
                    } while (uri == null);

                    sourceJson2 = new JsonPrimitive(uri);
                    specialCase = true;
                    break;
                case "null":
                    sourceJson = (JsonPrimitive)JsonValue.Parse("null");
                    sourceJson2 = null;
                    break;
                default:
                    sourceJson = null;
                    sourceJson2 = null;
                    break;
            }

            if (!specialCase)
            {
                // comparison between two constructors
                if (!JsonValueVerifier.Compare(sourceJson, sourceJson2))
                {
                    Log.Info("(JsonPrimitive)JsonValue.Parse(string) failed to match the results from default JsonPrimitive(obj)constructor for type {0}", typeName);
                    retValue = false;
                }

                if (sourceJson != null)
                {
                    // test JsonValue.Load(TextReader)
                    JsonPrimitive newJson = null;
                    using (StringReader sr = new StringReader(sourceJson.ToString()))
                    {
                        newJson = (JsonPrimitive)JsonValue.Load(sr);
                    }

                    if (!JsonValueVerifier.Compare(sourceJson, newJson))
                    {
                        Log.Info("JsonValue.Load(TextReader) failed to function properly for type {0}", typeName);
                        retValue = false;
                    }

                    // test JsonValue.Load(Stream) is located in the JObjectFromGenoTypeLib test case

                    // test JsonValue.Parse(string)
                    newJson = null;
                    newJson = (JsonPrimitive)JsonValue.Parse(sourceJson.ToString());
                    if (!JsonValueVerifier.Compare(sourceJson, newJson))
                    {
                        Log.Info("JsonValue.Parse(string) failed to function properly for type {0}", typeName);
                        retValue = false;
                    }
                }
            }
            else
            {
                // test JsonValue.Load(TextReader)
                JsonPrimitive newJson2 = null;
                using (StringReader sr = new StringReader(sourceJson2.ToString()))
                {
                    newJson2 = (JsonPrimitive)JsonValue.Load(sr);
                }

                if (!JsonValueVerifier.Compare(sourceJson2, newJson2))
                {
                    Log.Info("JsonValue.Load(TextReader) failed to function properly for type {0}", typeName);
                    retValue = false;
                }

                // test JsonValue.Load(Stream) is located in the JObjectFromGenoTypeLib test case

                // test JsonValue.Parse(string)
                newJson2 = null;
                newJson2 = (JsonPrimitive)JsonValue.Parse(sourceJson2.ToString());
                if (!JsonValueVerifier.Compare(sourceJson2, newJson2))
                {
                    Log.Info("JsonValue.Parse(string) failed to function properly for type {0}", typeName);
                    retValue = false;
                }
            }

            return retValue;
        }
        /// <summary>
        /// Gets the operation support value for the specified operation and operands.
        /// </summary>
        /// <param name="operation">The operation type.</param>
        /// <param name="thisValue">The JsonValue instance to check operation for.</param>
        /// <param name="operand">The second operand instance.</param>
        /// <returns>An <see cref="OperationSupport"/> value.</returns>
        private static OperationSupport GetBinaryOperationSupport(ExpressionType operation, JsonValue thisValue, object operand)
        {
            //// Supported binary operators: +, -, *, /, %, &, |, ^, <<, >>, ==, !=, >, <, >=, <=

            bool isCompareOperation = false;

            JsonValue otherValue = operand as JsonValue;

            switch (operation)
            {
            //// supported binary operations

            case ExpressionType.Add:
            case ExpressionType.Subtract:
            case ExpressionType.Multiply:
            case ExpressionType.Divide:
            case ExpressionType.Modulo:
            case ExpressionType.And:
            case ExpressionType.Or:
            case ExpressionType.ExclusiveOr:
            case ExpressionType.LeftShift:
            case ExpressionType.RightShift:
            case ExpressionType.GreaterThan:
            case ExpressionType.GreaterThanOrEqual:
            case ExpressionType.LessThan:
            case ExpressionType.LessThanOrEqual:
                break;

            //// compare operations:
            case ExpressionType.Equal:
            case ExpressionType.NotEqual:
                isCompareOperation = true;
                break;

            default:
                return(OperationSupport.NotSupported);
            }

            if (operand != null)
            {
                bool thisIsPrimitive = thisValue is JsonPrimitive;

                if (otherValue != null)
                {
                    if (!(otherValue is JsonPrimitive) || !thisIsPrimitive)
                    {
                        //// When either value is non-primitive it must be a compare operation.

                        if (!isCompareOperation)
                        {
                            return(OperationSupport.NotSupportedOnJsonType);
                        }
                    }
                }
                else
                {
                    //// if operand is not a JsonValue it must be a primitive CLR type and first operand must be a JsonPrimitive.

                    if (!thisIsPrimitive)
                    {
                        return(OperationSupport.NotSupportedOnJsonType);
                    }

                    JsonPrimitive primitiveValue = null;

                    if (!JsonPrimitive.TryCreate(operand, out primitiveValue))
                    {
                        return(OperationSupport.NotSupportedOnValueType);
                    }
                }
            }
            else
            {
                //// when operand is null only compare operations are valid.

                if (!isCompareOperation)
                {
                    return(OperationSupport.NotSupportedOnOperand);
                }
            }

            return(OperationSupport.Supported);
        }
Example #26
0
 void AddPrimitive(JsonPrimitive jsonPrimitive)
 {
     if (stack.Count == 0)
         root = jsonPrimitive;
     else
     {
         var parentContainer = stack.Peek();
         parentContainer.AddChild(jsonPrimitive);
     }
 }
Example #27
0
		// Convert a string to json and parse the string, then compare the result to the original value
		void CheckString (string str)
		{
			var json = new JsonPrimitive (str).ToString ();
			// Check whether the string is valid Unicode (will throw for broken surrogate pairs)
			new UTF8Encoding (false, true).GetBytes (json);
			string jvalue = (string) JsonValue.Parse (json);
			Assert.AreEqual (str, jvalue);
		}
Example #28
0
        public static JsonPrimitive GetRandomJsonPrimitives(int seed)
        {
            JsonPrimitive myObject;
            Random rndGen = new Random(seed);

            int mod = seed % 13;
            switch (mod)
            {
                case 1:
                    myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfBoolean(rndGen));
                    break;
                case 2:
                    myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfByte(rndGen));
                    break;
                case 3:
                    myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfDateTime(rndGen));
                    break;
                case 4:
                    myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfDecimal(rndGen));
                    break;
                case 5:
                    myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfInt16(rndGen));
                    break;
                case 6:
                    myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfInt32(rndGen));
                    break;
                case 7:
                    myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfInt64(rndGen));
                    break;
                case 8:
                    myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfSByte(rndGen));
                    break;
                case 9:
                    myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfSingle(rndGen));
                    break;
                case 10:
                    string temp;
                    do
                    {
                        temp = PrimitiveCreator.CreateInstanceOfString(rndGen);
                    }
                    while (temp == null);

                    myObject = new JsonPrimitive(temp);
                    break;
                case 11:
                    myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfUInt16(rndGen));
                    break;
                case 12:
                    myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfUInt32(rndGen));
                    break;
                default:
                    myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfUInt64(rndGen));
                    break;
            }

            return myObject;
        }
Example #29
0
        static IEnumerable<EmitValue> EnumeratePrimitiveIfNotNull(JsonPrimitive primitiveValue)
        {
            if (primitiveValue == null) yield break;

            switch (primitiveValue.JsonType)
            {
                case JsonType.String:
                    yield return new EmitValue(JsonToken.String, primitiveValue.Value);
                    yield break;
                case JsonType.Number:
                    yield return new EmitValue(
                        primitiveValue.Value is int? JsonToken.Integer: JsonToken.Float, primitiveValue.Value);
                    yield break;
                case JsonType.Boolean:
                    yield return new EmitValue(JsonToken.Boolean, primitiveValue.Value);
                    yield break;
                default:
                    throw new ArgumentOutOfRangeException();
            }
        }
        public void InvalidCastTest()
        {
            JsonValue nullValue = (JsonValue)null;
            JsonValue strValue = new JsonPrimitive(AnyInstance.AnyString);
            JsonValue boolValue = new JsonPrimitive(AnyInstance.AnyBool);
            JsonValue intValue = new JsonPrimitive(AnyInstance.AnyInt);

            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (double)nullValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (double)strValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (double)boolValue; });
            Assert.Equal<double>(AnyInstance.AnyInt, (double)intValue);

            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (float)nullValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (float)strValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (float)boolValue; });
            Assert.Equal<float>(AnyInstance.AnyInt, (float)intValue);

            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (decimal)nullValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (decimal)strValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (decimal)boolValue; });
            Assert.Equal<decimal>(AnyInstance.AnyInt, (decimal)intValue);

            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (long)nullValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (long)strValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (long)boolValue; });
            Assert.Equal<long>(AnyInstance.AnyInt, (long)intValue);

            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (ulong)nullValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (ulong)strValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (ulong)boolValue; });
            Assert.Equal<ulong>(AnyInstance.AnyInt, (ulong)intValue);

            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (int)nullValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (int)strValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (int)boolValue; });
            Assert.Equal<int>(AnyInstance.AnyInt, (int)intValue);

            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (uint)nullValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (uint)strValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (uint)boolValue; });
            Assert.Equal<uint>(AnyInstance.AnyInt, (uint)intValue);

            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (short)nullValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (short)strValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (short)boolValue; });

            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (ushort)nullValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (ushort)strValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (ushort)boolValue; });

            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (sbyte)nullValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (sbyte)strValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (sbyte)boolValue; });

            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (byte)nullValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (byte)strValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (byte)boolValue; });

            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (Guid)nullValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (Guid)strValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (Guid)boolValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (Guid)intValue; });

            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (DateTime)nullValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (DateTime)strValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (DateTime)boolValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (DateTime)intValue; });

            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (char)nullValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (char)strValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (char)boolValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (char)intValue; });

            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (DateTimeOffset)nullValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (DateTimeOffset)strValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (DateTimeOffset)boolValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (DateTimeOffset)intValue; });

            Assert.Null((Uri)nullValue);
            Assert.Equal(((Uri)strValue).ToString(), (string)strValue);
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (Uri)boolValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (Uri)intValue; });

            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (bool)nullValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (bool)strValue; });
            Assert.Equal(AnyInstance.AnyBool, (bool)boolValue);
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (bool)intValue; });

            Assert.Equal(null, (string)nullValue);
            Assert.Equal(AnyInstance.AnyString, (string)strValue);
            Assert.Equal(AnyInstance.AnyBool.ToString().ToLowerInvariant(), ((string)boolValue).ToLowerInvariant());
            Assert.Equal(AnyInstance.AnyInt.ToString(CultureInfo.InvariantCulture), (string)intValue);

            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (int)nullValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (int)strValue; });
            ExceptionHelper.Throws<InvalidCastException>(delegate { var v = (int)boolValue; });
            Assert.Equal(AnyInstance.AnyInt, (int)intValue);
        }
		public JsonValue containsKey(JsonValue value, string key, int type) {
			JsonPrimitive nullValue = new JsonPrimitive("");
			switch(type) {
			case JSON_TYPE_INT:
				nullValue = new JsonPrimitive(0);
				break;
			case 1:
				nullValue = new JsonPrimitive("");
				break;
			case 2:
				nullValue = new JsonPrimitive(new DateTime());
				break;
			}
			if(value == null)
				return nullValue;
			return (value.ContainsKey(key)) ? value[key] : nullValue;
		}
        public void ValidJsonObjectDateTimeOffsetRoundTrip()
        {
            int seed = 1;
            Log.Info("Seed: {0}", seed);
            Random rndGen = new Random(seed);

            JsonPrimitive sourceJson = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfDateTimeOffset(rndGen));
            JsonPrimitive newJson = (JsonPrimitive)JsonValue.Parse(sourceJson.ToString());

            if (!JsonValueVerifier.Compare(sourceJson, newJson))
            {
                Assert.Fail("Test failed!  The new JsonObject DateTimeOffset value does not equal to the original one.");
            }
        }
        public void InvalidCastTest()
        {
            JsonValue nullValue = (JsonValue)null;
            JsonValue strValue  = new JsonPrimitive(AnyInstance.AnyString);
            JsonValue boolValue = new JsonPrimitive(AnyInstance.AnyBool);
            JsonValue intValue  = new JsonPrimitive(AnyInstance.AnyInt);

            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (double)nullValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (double)strValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (double)boolValue; });
            Assert.Equal <double>(AnyInstance.AnyInt, (double)intValue);

            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (float)nullValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (float)strValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (float)boolValue; });
            Assert.Equal <float>(AnyInstance.AnyInt, (float)intValue);

            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (decimal)nullValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (decimal)strValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (decimal)boolValue; });
            Assert.Equal <decimal>(AnyInstance.AnyInt, (decimal)intValue);

            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (long)nullValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (long)strValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (long)boolValue; });
            Assert.Equal <long>(AnyInstance.AnyInt, (long)intValue);

            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (ulong)nullValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (ulong)strValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (ulong)boolValue; });
            Assert.Equal <ulong>(AnyInstance.AnyInt, (ulong)intValue);

            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (int)nullValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (int)strValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (int)boolValue; });
            Assert.Equal <int>(AnyInstance.AnyInt, (int)intValue);

            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (uint)nullValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (uint)strValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (uint)boolValue; });
            Assert.Equal <uint>(AnyInstance.AnyInt, (uint)intValue);

            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (short)nullValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (short)strValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (short)boolValue; });

            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (ushort)nullValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (ushort)strValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (ushort)boolValue; });

            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (sbyte)nullValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (sbyte)strValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (sbyte)boolValue; });

            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (byte)nullValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (byte)strValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (byte)boolValue; });

            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (Guid)nullValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (Guid)strValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (Guid)boolValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (Guid)intValue; });

            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (DateTime)nullValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (DateTime)strValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (DateTime)boolValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (DateTime)intValue; });

            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (char)nullValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (char)strValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (char)boolValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (char)intValue; });

            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (DateTimeOffset)nullValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (DateTimeOffset)strValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (DateTimeOffset)boolValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (DateTimeOffset)intValue; });

            Assert.Null((Uri)nullValue);
            Assert.Equal(((Uri)strValue).ToString(), (string)strValue);
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (Uri)boolValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (Uri)intValue; });

            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (bool)nullValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (bool)strValue; });
            Assert.Equal(AnyInstance.AnyBool, (bool)boolValue);
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (bool)intValue; });

            Assert.Equal(null, (string)nullValue);
            Assert.Equal(AnyInstance.AnyString, (string)strValue);
            Assert.Equal(AnyInstance.AnyBool.ToString().ToLowerInvariant(), ((string)boolValue).ToLowerInvariant());
            Assert.Equal(AnyInstance.AnyInt.ToString(CultureInfo.InvariantCulture), (string)intValue);

            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (int)nullValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (int)strValue; });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var v = (int)boolValue; });
            Assert.Equal(AnyInstance.AnyInt, (int)intValue);
        }
        public void JsonObjectItemsFunctionalTest()
        {
            int seed = 1;

            for (int i = 0; i < iterationCount / 10; i++)
            {
                seed++;
                Log.Info("Seed: {0}", seed);
                Random rndGen   = new Random(seed);
                bool   retValue = true;

                JsonObject sourceJson = SpecialJsonValueHelper.CreateIndexPopulatedJsonObject(seed, arrayLength);

                // JsonObject[key].set_Item
                sourceJson["1"] = new JsonPrimitive(true);
                if (sourceJson["1"].ToString() != "true")
                {
                    Log.Info("[JsonObjectItemsFunctionalTest] JsonObject[key].set_Item failed to function properly.");
                    retValue = false;
                }
                else
                {
                    Log.Info("[JsonObjectItemsFunctionalTest] JsonObject[key].set_Item passed test.");
                }

                // ICollection<KeyValuePair<string, JsonValue>>.Contains(KeyValuePair<string, JsonValue> item)
                KeyValuePair <string, System.Json.JsonValue> kp = new KeyValuePair <string, JsonValue>("5", sourceJson["5"]);
                if (!((ICollection <KeyValuePair <string, JsonValue> >)sourceJson).Contains(kp))
                {
                    Log.Info("[JsonObjectItemsFunctionalTest] ICollection<KeyValuePair<string, JsonValue>>.Contains(KeyValuePair<string, JsonValue> item) failed to function properly.");
                    retValue = false;
                }
                else
                {
                    Log.Info("[JsonObjectItemsFunctionalTest] ICollection<KeyValuePair<string, JsonValue>>.Contains(KeyValuePair<string, JsonValue> item) passed test.");
                }

                // ICollection<KeyValuePair<string, JsonValue>>.IsReadOnly
                if (((ICollection <KeyValuePair <string, JsonValue> >)sourceJson).IsReadOnly)
                {
                    Log.Info("[JsonObjectItemsFunctionalTest] ICollection<KeyValuePair<string, JsonValue>>.IsReadOnly failed to function properly.");
                    retValue = false;
                }
                else
                {
                    Log.Info("[JsonObjectItemsFunctionalTest] ICollection<KeyValuePair<string, JsonValue>>.IsReadOnly passed test.");
                }

                // ICollection<KeyValuePair<string, JsonValue>>.Add(KeyValuePair<string, JsonValue> item)
                kp = new KeyValuePair <string, JsonValue>("100", new JsonPrimitive(100));
                ((ICollection <KeyValuePair <string, JsonValue> >)sourceJson).Add(kp);
                if (sourceJson.Count != arrayLength + 1)
                {
                    Log.Info("[JsonObjectItemsFunctionalTest] ICollection<KeyValuePair<string, JsonValue>>.Add(KeyValuePair<string, JsonValue> item) failed to function properly.");
                    retValue = false;
                }
                else
                {
                    Log.Info("[JsonObjectItemsFunctionalTest] ICollection<KeyValuePair<string, JsonValue>>.Add(KeyValuePair<string, JsonValue> item) passed test.");
                }

                // ICollection<KeyValuePair<string, JsonValue>>.Remove(KeyValuePair<string, JsonValue> item)
                ((ICollection <KeyValuePair <string, JsonValue> >)sourceJson).Remove(kp);
                if (sourceJson.Count != arrayLength)
                {
                    Log.Info("[JsonObjectItemsFunctionalTest] ICollection<KeyValuePair<string, JsonValue>>.Remove(KeyValuePair<string, JsonValue> item) failed to function properly.");
                    retValue = false;
                }
                else
                {
                    Log.Info("[JsonObjectItemsFunctionalTest] ICollection<KeyValuePair<string, JsonValue>>.Remove(KeyValuePair<string, JsonValue> item) passed test.");
                }

                // ICollection<KeyValuePair<string, JsonValue>>.GetEnumerator()
                JsonObject jo = new JsonObject {
                    { "member 1", 123 }, { "member 2", new JsonArray {
                                               1, 2, 3
                                           } }
                };
                List <string> expected = new List <string> {
                    "member 1 - 123", "member 2 - [1,2,3]"
                };
                expected.Sort();
                IEnumerator <KeyValuePair <string, JsonValue> > ko = ((ICollection <KeyValuePair <string, JsonValue> >)jo).GetEnumerator();
                List <string> actual = new List <string>();
                ko.Reset();
                ko.MoveNext();
                do
                {
                    actual.Add(String.Format("{0} - {1}", ko.Current.Key, ko.Current.Value.ToString()));
                    Log.Info("added one item: {0}", String.Format("{0} - {1}", ko.Current.Key, ko.Current.Value));
                    ko.MoveNext();
                }while (ko.Current.Value != null);

                actual.Sort();
                if (!JsonValueVerifier.CompareStringLists(expected, actual))
                {
                    Log.Info("[JsonObjectItemsFunctionalTest] ICollection<KeyValuePair<string, JsonValue>>.GetEnumerator() failed to function properly.");
                    retValue = false;
                }
                else
                {
                    Log.Info("[JsonObjectItemsFunctionalTest] ICollection<KeyValuePair<string, JsonValue>>.GetEnumerator() passed test.");
                }

                // JsonObject.Values
                sourceJson = SpecialJsonValueHelper.CreateIndexPopulatedJsonObject(seed, arrayLength);
                JsonValue[] manyValues = SpecialJsonValueHelper.CreatePrePopulatedJsonValueArray(seed, arrayLength);
                JsonObject  jov        = new JsonObject();
                for (int j = 0; j < manyValues.Length; j++)
                {
                    jov.Add("member" + j, manyValues[j]);
                }

                List <string> expectedList = new List <string>();
                foreach (JsonValue v in manyValues)
                {
                    expectedList.Add(v.ToString());
                }

                expectedList.Sort();
                List <string> actualList = new List <string>();
                foreach (JsonValue v in jov.Values)
                {
                    actualList.Add(v.ToString());
                }

                actualList.Sort();
                if (!JsonValueVerifier.CompareStringLists(expectedList, actualList))
                {
                    Log.Info("[JsonObjectItemsFunctionalTest] JsonObject.Values failed to function properly.");
                    retValue = false;
                }
                else
                {
                    Log.Info("[JsonObjectItemsFunctionalTest] JsonObject.Values passed test.");
                }

                for (int j = 0; j < sourceJson.Count; j++)
                {
                    // JsonObject.Contains(Key)
                    if (!sourceJson.ContainsKey(j.ToString()))
                    {
                        Log.Info("[JsonObjectItemsFunctionalTest] JsonObject.Contains(Key) failed to function properly.");
                        retValue = false;
                    }
                    else
                    {
                        Log.Info("[JsonObjectItemsFunctionalTest] JsonObject.Contains(Key) passed test.");
                    }

                    // JsonObject.TryGetValue(String, out JsonValue)
                    JsonValue retJson;
                    if (!sourceJson.TryGetValue(j.ToString(), out retJson))
                    {
                        Log.Info("[JsonObjectItemsFunctionalTest] JsonObject.TryGetValue(String, out JsonValue) failed to function properly.");
                        retValue = false;
                    }
                    else if (retJson != sourceJson[j.ToString()])
                    {
                        // JsonObjectthis[string key]
                        Log.Info("[JsonObjectItemsFunctionalTest] JsonObject[string key] or JsonObject.TryGetValue(String, out JsonValue) failed to function properly.");
                        retValue = false;
                    }
                    else
                    {
                        Log.Info("[JsonObjectItemsFunctionalTest] JsonObject.TryGetValue(String, out JsonValue) & JsonObject[string key] passed test.");
                    }
                }

                Assert.True(retValue);
            }
        }
 public void ReadAsTest()
 {
     JsonValue target = new JsonPrimitive(AnyInstance.AnyInt);
     Assert.Equal(AnyInstance.AnyInt.ToString(CultureInfo.InvariantCulture), target.ReadAs(typeof(string)));
     Assert.Equal(AnyInstance.AnyInt.ToString(CultureInfo.InvariantCulture), target.ReadAs<string>());
     object value;
     double dblValue;
     Assert.True(target.TryReadAs(typeof(double), out value));
     Assert.True(target.TryReadAs<double>(out dblValue));
     Assert.Equal(Convert.ToDouble(AnyInstance.AnyInt, CultureInfo.InvariantCulture), (double)value);
     Assert.Equal(Convert.ToDouble(AnyInstance.AnyInt, CultureInfo.InvariantCulture), dblValue);
     Assert.False(target.TryReadAs(typeof(Guid), out value), "TryReadAs should have failed to read a double as a Guid");
     Assert.Null(value);
 }
        public void BindUnaryOperationTest()
        {
            JsonValue value;
            DynamicMetaObject target;

            value =  new JsonPrimitive(AnyInstance.AnyInt);
            target = GetJsonValueDynamicMetaObject(value);

            TestUnaryOperationBinder.TestBindParams(target);
            TestUnaryOperationBinder.TestMetaObject(target, TestUnaryOperationBinder.NumberOperations);

            value = new JsonPrimitive(AnyInstance.AnyBool);
            target = GetJsonValueDynamicMetaObject(value);

            TestUnaryOperationBinder.TestMetaObject(target, TestUnaryOperationBinder.BooleanOperations);
        }
Example #37
0
        public void StringToNonNumberConversionTest()
        {
            const string DateTimeWithOffsetFormat = "yyyy-MM-ddTHH:mm:sszzz";
            const string DateTimeWithOffsetFormat2 = "yyy-MM-ddTHH:mm:ss.fffK";
            const string DateTimeWithoutOffsetWithoutTimeFormat = "yyy-MM-dd";
            const string DateTimeWithoutOffsetFormat = "yyy-MM-ddTHH:mm:ss";
            const string DateTimeWithoutOffsetFormat2 = "yyy-MM-ddTHH:mm:ss.fff";
            const string TimeWithoutOffsetFormat = "HH:mm:ss";
            const string TimeWithoutOffsetFormat2 = "HH:mm";

            Assert.AreEqual(false, new JsonPrimitive("false").ReadAs<bool>());
            Assert.AreEqual(false, (bool)(new JsonPrimitive("False")));
            Assert.AreEqual(true, (bool)(new JsonPrimitive("true")));
            Assert.AreEqual(true, new JsonPrimitive("True").ReadAs<bool>());

            Assert.AreEqual<Uri>(AnyInstance.AnyUri, new JsonPrimitive(AnyInstance.AnyUri.ToString()).ReadAs<Uri>());
            Assert.AreEqual<char>(AnyInstance.AnyChar, (char)(new JsonPrimitive(new string(AnyInstance.AnyChar, 1))));
            Assert.AreEqual<Guid>(AnyInstance.AnyGuid, (Guid)(new JsonPrimitive(AnyInstance.AnyGuid.ToString("D", CultureInfo.InvariantCulture))));

            DateTime anyLocalDateTime = AnyInstance.AnyDateTime.ToLocalTime();
            DateTime anyUtcDateTime = AnyInstance.AnyDateTime.ToUniversalTime();

            Assert.AreEqual<DateTime>(anyUtcDateTime, (DateTime)(new JsonPrimitive(anyUtcDateTime.ToString(DateTimeFormat, CultureInfo.InvariantCulture))));
            Assert.AreEqual<DateTime>(anyLocalDateTime, new JsonPrimitive(anyLocalDateTime.ToString(DateTimeWithOffsetFormat2, CultureInfo.InvariantCulture)).ReadAs<DateTime>());
            Assert.AreEqual<DateTime>(anyUtcDateTime, new JsonPrimitive(anyUtcDateTime.ToString(DateTimeWithOffsetFormat2, CultureInfo.InvariantCulture)).ReadAs<DateTime>());
            Assert.AreEqual<DateTime>(anyLocalDateTime.Date, (DateTime)(new JsonPrimitive(anyLocalDateTime.ToString(DateTimeWithoutOffsetWithoutTimeFormat, CultureInfo.InvariantCulture))));
            Assert.AreEqual<DateTime>(anyLocalDateTime, new JsonPrimitive(anyLocalDateTime.ToString(DateTimeWithoutOffsetFormat, CultureInfo.InvariantCulture)).ReadAs<DateTime>());
            Assert.AreEqual<DateTime>(anyLocalDateTime, new JsonPrimitive(anyLocalDateTime.ToString(DateTimeWithoutOffsetFormat2, CultureInfo.InvariantCulture)).ReadAs<DateTime>());

            DateTime dt = new JsonPrimitive(anyLocalDateTime.ToString(TimeWithoutOffsetFormat, CultureInfo.InvariantCulture)).ReadAs<DateTime>();
            Assert.AreEqual(anyLocalDateTime.Hour, dt.Hour);
            Assert.AreEqual(anyLocalDateTime.Minute, dt.Minute);
            Assert.AreEqual(anyLocalDateTime.Second, dt.Second);

            dt = new JsonPrimitive(anyLocalDateTime.ToString(TimeWithoutOffsetFormat2, CultureInfo.InvariantCulture)).ReadAs<DateTime>();
            Assert.AreEqual(anyLocalDateTime.Hour, dt.Hour);
            Assert.AreEqual(anyLocalDateTime.Minute, dt.Minute);
            Assert.AreEqual(0, dt.Second);

            Assert.AreEqual<DateTimeOffset>(AnyInstance.AnyDateTimeOffset, new JsonPrimitive(AnyInstance.AnyDateTimeOffset.ToString(DateTimeFormat, CultureInfo.InvariantCulture)).ReadAs<DateTimeOffset>());
            Assert.AreEqual<DateTimeOffset>(AnyInstance.AnyDateTimeOffset, new JsonPrimitive(AnyInstance.AnyDateTimeOffset.ToString(DateTimeWithOffsetFormat, CultureInfo.InvariantCulture)).ReadAs<DateTimeOffset>());
            Assert.AreEqual<DateTimeOffset>(AnyInstance.AnyDateTimeOffset, new JsonPrimitive(AnyInstance.AnyDateTimeOffset.ToString(DateTimeWithOffsetFormat2, CultureInfo.InvariantCulture)).ReadAs<DateTimeOffset>());
            Assert.AreEqual<DateTimeOffset>(AnyInstance.AnyDateTimeOffset.ToLocalTime(), (DateTimeOffset)(new JsonPrimitive(AnyInstance.AnyDateTimeOffset.ToLocalTime().ToString(DateTimeWithoutOffsetFormat, CultureInfo.InvariantCulture))));
            Assert.AreEqual<DateTimeOffset>(AnyInstance.AnyDateTimeOffset.ToLocalTime(), (DateTimeOffset)(new JsonPrimitive(AnyInstance.AnyDateTimeOffset.ToLocalTime().ToString(DateTimeWithoutOffsetFormat2, CultureInfo.InvariantCulture))));

            DataContractJsonSerializer dcjs = new DataContractJsonSerializer(typeof(DateTime));
            MemoryStream ms = new MemoryStream();
            dcjs.WriteObject(ms, AnyInstance.AnyDateTime);
            string dcjsSerializedDateTime = Encoding.UTF8.GetString(ms.ToArray());
            Assert.AreEqual(AnyInstance.AnyDateTime, JsonValue.Parse(dcjsSerializedDateTime).ReadAs<DateTime>());

            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { var b = (bool)(new JsonPrimitive("notBool")); });
            ExceptionTestHelper.ExpectException<UriFormatException>(delegate { var u = new JsonPrimitive("not an uri - " + new string('r', 100000)).ReadAs<Uri>(); });
            ExceptionTestHelper.ExpectException<FormatException>(delegate { var date = new JsonPrimitive("not a date time").ReadAs<DateTime>(); });
            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { var dto = (DateTimeOffset)(new JsonPrimitive("not a date time offset")); });
            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { var c = (char)new JsonPrimitive(""); });
            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { var c = (char)new JsonPrimitive("cc"); });
            ExceptionTestHelper.ExpectException<FormatException>(delegate { var g = new JsonPrimitive("not a guid").ReadAs<Guid>(); });
        }
        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); });
        }
Example #39
0
        public void NonNumberToNumberConversionTest()
        {
            Assert.AreEqual(1, new JsonPrimitive('1').ReadAs<int>());
            Assert.AreEqual<byte>(AnyInstance.AnyByte, new JsonPrimitive(AnyInstance.AnyByte.ToString(CultureInfo.InvariantCulture)).ReadAs<byte>());
            Assert.AreEqual<sbyte>(AnyInstance.AnySByte, (sbyte)(new JsonPrimitive(AnyInstance.AnySByte.ToString(CultureInfo.InvariantCulture))));
            Assert.AreEqual<short>(AnyInstance.AnyShort, (short)(new JsonPrimitive(AnyInstance.AnyShort.ToString(CultureInfo.InvariantCulture))));
            Assert.AreEqual<ushort>(AnyInstance.AnyUShort, new JsonPrimitive(AnyInstance.AnyUShort.ToString(CultureInfo.InvariantCulture)).ReadAs<ushort>());
            Assert.AreEqual<int>(AnyInstance.AnyInt, new JsonPrimitive(AnyInstance.AnyInt.ToString(CultureInfo.InvariantCulture)).ReadAs<int>());
            Assert.AreEqual<uint>(AnyInstance.AnyUInt, (uint)(new JsonPrimitive(AnyInstance.AnyUInt.ToString(CultureInfo.InvariantCulture))));
            Assert.AreEqual<long>(AnyInstance.AnyLong, (long)(new JsonPrimitive(AnyInstance.AnyLong.ToString(CultureInfo.InvariantCulture))));
            Assert.AreEqual<ulong>(AnyInstance.AnyULong, new JsonPrimitive(AnyInstance.AnyULong.ToString(CultureInfo.InvariantCulture)).ReadAs<ulong>());

            Assert.AreEqual<decimal>(AnyInstance.AnyDecimal, (decimal)(new JsonPrimitive(AnyInstance.AnyDecimal.ToString(CultureInfo.InvariantCulture))));
            Assert.AreEqual<float>(AnyInstance.AnyFloat, new JsonPrimitive(AnyInstance.AnyFloat.ToString(CultureInfo.InvariantCulture)).ReadAs<float>());
            Assert.AreEqual<double>(AnyInstance.AnyDouble, (double)(new JsonPrimitive(AnyInstance.AnyDouble.ToString(CultureInfo.InvariantCulture))));

            Assert.AreEqual<byte>(Convert.ToByte(1.23, CultureInfo.InvariantCulture), new JsonPrimitive("1.23").ReadAs<byte>());
            Assert.AreEqual<int>(Convert.ToInt32(12345.6789, CultureInfo.InvariantCulture), new JsonPrimitive("12345.6789").ReadAs<int>());
            Assert.AreEqual<short>(Convert.ToInt16(1.23e2), (short)new JsonPrimitive("1.23e2"));
            Assert.AreEqual<float>(Convert.ToSingle(1.23e40), (float)new JsonPrimitive("1.23e40"));
            Assert.AreEqual<float>(Convert.ToSingle(1.23e-38), (float)new JsonPrimitive("1.23e-38"));

            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyBool).ReadAs<sbyte>(); });
            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyBool).ReadAs<short>(); });
            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyBool).ReadAs<uint>(); });
            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyBool).ReadAs<long>(); });
            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyBool).ReadAs<double>(); });

            ExceptionTestHelper.ExpectException<FormatException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyUri).ReadAs<int>(); });
            ExceptionTestHelper.ExpectException<FormatException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyDateTime).ReadAs<float>(); });
            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { var n = (decimal)(new JsonPrimitive('c')); });
            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { var n = (byte)(new JsonPrimitive("0xFF")); });
            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { var n = (sbyte)(new JsonPrimitive(AnyInstance.AnyDateTimeOffset)); });
            ExceptionTestHelper.ExpectException<FormatException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyUri).ReadAs<uint>(); });
            ExceptionTestHelper.ExpectException<FormatException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyDateTime).ReadAs<double>(); });
            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { var n = (long)(new JsonPrimitive('c')); });
            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { var n = (ulong)(new JsonPrimitive("0xFF")); });
            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { var n = (short)(new JsonPrimitive(AnyInstance.AnyDateTimeOffset)); });
            ExceptionTestHelper.ExpectException<InvalidCastException>(delegate { var n = (ushort)(new JsonPrimitive('c')); });

            ExceptionTestHelper.ExpectException<OverflowException>(delegate { int i = (int)new JsonPrimitive((1L << 32).ToString(CultureInfo.InvariantCulture)); });
            ExceptionTestHelper.ExpectException<OverflowException>(delegate { byte b = (byte)new JsonPrimitive("-1"); });
        }
Example #40
0
        // the input JsonPrimitive DateTime format is "\/Date(24735422733034-0700)\/" or "\/Date(24735422733034)\/"
        // the only thing useful for us is the UTC ticks "24735422733034"
        // everything after - if present - is just an optional offset between the local time and UTC
        private static string GetUTCTicks(JsonPrimitive jprim)
        {
            string retValue = string.Empty;

            string origStr = jprim.ToString();
            int startIndex = origStr.IndexOf("Date(") + 5;
            int endIndex = origStr.IndexOf('-', startIndex + 1); // the UTC ticks can start with a '-' sign (dates prior to 1970/01/01)

            // if the optional offset is present in the data format, we want to take only the UTC ticks
            if (startIndex < endIndex)
            {
                retValue = origStr.Substring(startIndex, endIndex - startIndex);
            }
            else
            {
                // otherwise we assume the time format is without the oiptional offset, or unexpected, and use the whole string for comparison.
                retValue = origStr;
            }

            return retValue;
        }
        public void StringToNonNumberConversionTest()
        {
            const string DateTimeWithOffsetFormat  = "yyyy-MM-ddTHH:mm:sszzz";
            const string DateTimeWithOffsetFormat2 = "yyy-MM-ddTHH:mm:ss.fffK";
            const string DateTimeWithoutOffsetWithoutTimeFormat = "yyy-MM-dd";
            const string DateTimeWithoutOffsetFormat            = "yyy-MM-ddTHH:mm:ss";
            const string DateTimeWithoutOffsetFormat2           = "yyy-MM-ddTHH:mm:ss.fff";
            const string TimeWithoutOffsetFormat  = "HH:mm:ss";
            const string TimeWithoutOffsetFormat2 = "HH:mm";

            Assert.Equal(false, new JsonPrimitive("false").ReadAs <bool>());
            Assert.Equal(false, (bool)(new JsonPrimitive("False")));
            Assert.Equal(true, (bool)(new JsonPrimitive("true")));
            Assert.Equal(true, new JsonPrimitive("True").ReadAs <bool>());

            Assert.Equal <Uri>(AnyInstance.AnyUri, new JsonPrimitive(AnyInstance.AnyUri.ToString()).ReadAs <Uri>());
            Assert.Equal <char>(AnyInstance.AnyChar, (char)(new JsonPrimitive(new string(AnyInstance.AnyChar, 1))));
            Assert.Equal <Guid>(AnyInstance.AnyGuid, (Guid)(new JsonPrimitive(AnyInstance.AnyGuid.ToString("D", CultureInfo.InvariantCulture))));

            DateTime anyLocalDateTime = AnyInstance.AnyDateTime.ToLocalTime();
            DateTime anyUtcDateTime   = AnyInstance.AnyDateTime.ToUniversalTime();

            Assert.Equal <DateTime>(anyUtcDateTime, (DateTime)(new JsonPrimitive(anyUtcDateTime.ToString(DateTimeFormat, CultureInfo.InvariantCulture))));
            Assert.Equal <DateTime>(anyLocalDateTime, new JsonPrimitive(anyLocalDateTime.ToString(DateTimeWithOffsetFormat2, CultureInfo.InvariantCulture)).ReadAs <DateTime>());
            Assert.Equal <DateTime>(anyUtcDateTime, new JsonPrimitive(anyUtcDateTime.ToString(DateTimeWithOffsetFormat2, CultureInfo.InvariantCulture)).ReadAs <DateTime>());
            Assert.Equal <DateTime>(anyLocalDateTime.Date, (DateTime)(new JsonPrimitive(anyLocalDateTime.ToString(DateTimeWithoutOffsetWithoutTimeFormat, CultureInfo.InvariantCulture))));
            Assert.Equal <DateTime>(anyLocalDateTime, new JsonPrimitive(anyLocalDateTime.ToString(DateTimeWithoutOffsetFormat, CultureInfo.InvariantCulture)).ReadAs <DateTime>());
            Assert.Equal <DateTime>(anyLocalDateTime, new JsonPrimitive(anyLocalDateTime.ToString(DateTimeWithoutOffsetFormat2, CultureInfo.InvariantCulture)).ReadAs <DateTime>());

            DateTime dt = new JsonPrimitive(anyLocalDateTime.ToString(TimeWithoutOffsetFormat, CultureInfo.InvariantCulture)).ReadAs <DateTime>();

            Assert.Equal(anyLocalDateTime.Hour, dt.Hour);
            Assert.Equal(anyLocalDateTime.Minute, dt.Minute);
            Assert.Equal(anyLocalDateTime.Second, dt.Second);

            dt = new JsonPrimitive(anyLocalDateTime.ToString(TimeWithoutOffsetFormat2, CultureInfo.InvariantCulture)).ReadAs <DateTime>();
            Assert.Equal(anyLocalDateTime.Hour, dt.Hour);
            Assert.Equal(anyLocalDateTime.Minute, dt.Minute);
            Assert.Equal(0, dt.Second);

            Assert.Equal <DateTimeOffset>(AnyInstance.AnyDateTimeOffset, new JsonPrimitive(AnyInstance.AnyDateTimeOffset.ToString(DateTimeFormat, CultureInfo.InvariantCulture)).ReadAs <DateTimeOffset>());
            Assert.Equal <DateTimeOffset>(AnyInstance.AnyDateTimeOffset, new JsonPrimitive(AnyInstance.AnyDateTimeOffset.ToString(DateTimeWithOffsetFormat, CultureInfo.InvariantCulture)).ReadAs <DateTimeOffset>());
            Assert.Equal <DateTimeOffset>(AnyInstance.AnyDateTimeOffset, new JsonPrimitive(AnyInstance.AnyDateTimeOffset.ToString(DateTimeWithOffsetFormat2, CultureInfo.InvariantCulture)).ReadAs <DateTimeOffset>());
            Assert.Equal <DateTimeOffset>(AnyInstance.AnyDateTimeOffset.ToLocalTime(), (DateTimeOffset)(new JsonPrimitive(AnyInstance.AnyDateTimeOffset.ToLocalTime().ToString(DateTimeWithoutOffsetFormat, CultureInfo.InvariantCulture))));
            Assert.Equal <DateTimeOffset>(AnyInstance.AnyDateTimeOffset.ToLocalTime(), (DateTimeOffset)(new JsonPrimitive(AnyInstance.AnyDateTimeOffset.ToLocalTime().ToString(DateTimeWithoutOffsetFormat2, CultureInfo.InvariantCulture))));

            DataContractJsonSerializer dcjs = new DataContractJsonSerializer(typeof(DateTime));
            MemoryStream ms = new MemoryStream();

            dcjs.WriteObject(ms, AnyInstance.AnyDateTime);
            string dcjsSerializedDateTime = Encoding.UTF8.GetString(ms.ToArray());

            Assert.Equal(AnyInstance.AnyDateTime, JsonValue.Parse(dcjsSerializedDateTime).ReadAs <DateTime>());

            ExceptionHelper.Throws <InvalidCastException>(delegate { var b = (bool)(new JsonPrimitive("notBool")); });
            ExceptionHelper.Throws <UriFormatException>(delegate { var u = new JsonPrimitive("not an uri - " + new string('r', 100000)).ReadAs <Uri>(); });
            ExceptionHelper.Throws <FormatException>(delegate { var date = new JsonPrimitive("not a date time").ReadAs <DateTime>(); });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var dto = (DateTimeOffset)(new JsonPrimitive("not a date time offset")); });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var c = (char)new JsonPrimitive(""); });
            ExceptionHelper.Throws <InvalidCastException>(delegate { var c = (char)new JsonPrimitive("cc"); });
            ExceptionHelper.Throws <FormatException>(delegate { var g = new JsonPrimitive("not a guid").ReadAs <Guid>(); });
        }
 public object FromPrimitive(JsonPrimitive value)
 {
     return this.m_from(value);
 }
Example #43
0
        public static JsonPrimitive GetRandomJsonPrimitives(int seed)
        {
            JsonPrimitive myObject;
            Random        rndGen = new Random(seed);

            int mod = seed % 13;

            switch (mod)
            {
            case 1:
                myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfBoolean(rndGen));
                break;

            case 2:
                myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfByte(rndGen));
                break;

            case 3:
                myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfDateTime(rndGen));
                break;

            case 4:
                myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfDecimal(rndGen));
                break;

            case 5:
                myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfInt16(rndGen));
                break;

            case 6:
                myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfInt32(rndGen));
                break;

            case 7:
                myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfInt64(rndGen));
                break;

            case 8:
                myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfSByte(rndGen));
                break;

            case 9:
                myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfSingle(rndGen));
                break;

            case 10:
                string temp;
                do
                {
                    temp = PrimitiveCreator.CreateInstanceOfString(rndGen);
                }while (temp == null);

                myObject = new JsonPrimitive(temp);
                break;

            case 11:
                myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfUInt16(rndGen));
                break;

            case 12:
                myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfUInt32(rndGen));
                break;

            default:
                myObject = new JsonPrimitive(PrimitiveCreator.CreateInstanceOfUInt64(rndGen));
                break;
            }

            return(myObject);
        }