public void DoubleValueReturns64BitFloatingPointValue()
{
// when
Assert.That(JsonNumberValue.FromDouble(Math.PI).DoubleValue, Is.EqualTo(Math.PI));
Assert.That(JsonNumberValue.FromDouble(Math.E).DoubleValue, Is.EqualTo(Math.E));
}
public void FromNumberLiteralReturnsNullForNotParsableLong()
{
// when constructed from a positive integer literal
var obtained = JsonNumberValue.FromNumberLiteral("9223372036854775808");
// then
Assert.That(obtained, Is.Null);
}
public void IntValueReturnsCastedValueFromLong()
{
// given
const int expected = unchecked ((int)0xdeadbabe);
// when constructed from a that does not fit into 32-bit
Assert.That(JsonNumberValue.FromLong(0x11111111deadbabe).IntValue, Is.EqualTo(expected));
}
public void IsIntValueReturnsTrueIfIsInsideIntRange()
{
// when minimum int value is used
Assert.That(JsonNumberValue.FromLong(int.MinValue).IsIntValue, Is.True);
// when maximum int value is used
Assert.That(JsonNumberValue.FromLong(int.MaxValue).IsIntValue, Is.True);
}
public void IsIntegerWhenConstructingWithLong()
{
// given
var target = JsonNumberValue.FromLong(42);
// then
Assert.That(target.IsInteger, Is.True);
}
public void IsIntValueReturnsFalseIfOutsideOfIntRange()
{
// when one less then minimum int value
Assert.That(JsonNumberValue.FromLong(int.MinValue - 1L).IsIntValue, Is.False);
// when one more then maximum int value
Assert.That(JsonNumberValue.FromLong(int.MaxValue + 1L).IsIntValue, Is.False);
}
public void IsIntValueReturnsFalseIfFromFloatingPointValue()
{
// when fit into integer value
Assert.That(JsonNumberValue.FromDouble(42).IsIntValue, Is.False);
// when an actual floating point number
Assert.That(JsonNumberValue.FromDouble(3.14159).IsIntValue, Is.False);
}
public void LongValueReturnsTruncatedValueWhenConstructedFromDouble()
{
// when constructed from a double with fractional part
Assert.That(JsonNumberValue.FromDouble(Math.PI).LongValue, Is.EqualTo(3));
// when constructed from another double with fractional part
Assert.That(JsonNumberValue.FromDouble(Math.E).LongValue, Is.EqualTo(2));
}
public void IntValueReturnsCastedValueFromDouble()
{
// when constructed from a double with fractional part
Assert.That(JsonNumberValue.FromDouble(Math.PI).IntValue, Is.EqualTo(3));
// when constructed from another double with fractional part
Assert.That(JsonNumberValue.FromDouble(Math.E).IntValue, Is.EqualTo(2));
}
public void FromNumberLiteralReturnsIntegerRepresentationForIntegerNumbers()
{
// when constructed with positive integer literal
var obtained = JsonNumberValue.FromNumberLiteral("1234567890");
// then
Assert.That(obtained, Is.Not.Null);
Assert.That(obtained.IsInteger, Is.True);
Assert.That(obtained.LongValue, Is.EqualTo(1234567890));
}
public void FromNumberLiteralReturnsDoubleIfLiteralContainsFractionAndExponentPart()
{
// when
var obtained = JsonNumberValue.FromNumberLiteral("0.0625e+2");
// then
Assert.That(obtained, Is.Not.Null);
Assert.That(obtained.IsInteger, Is.False);
Assert.That(obtained.DoubleValue, Is.EqualTo(6.25d));
}
public void FromNumberLiteralReturnsDoubleIfLiteralContainsExponentPart()
{
// when constructed from positive floating point literal
var obtained = JsonNumberValue.FromNumberLiteral("15E-1");
// then
Assert.That(obtained, Is.Not.Null);
Assert.That(obtained.IsInteger, Is.False);
Assert.That(obtained.DoubleValue, Is.EqualTo(1.5));
}
public void FromNumberLiteralReturnsDoubleIfLiteralContainsNegativeValue()
{
// when constructed from a negative floating point literal
var obtained = JsonNumberValue.FromNumberLiteral("-1.25");
// then
Assert.That(obtained, Is.Not.Null);
Assert.That(obtained.IsInteger, Is.False);
Assert.That(obtained.DoubleValue, Is.EqualTo(-1.25));
}
public void FromNumberLiteralReturnsLongIfLiteralContainsNegativeValue()
{
// when constructed from a negative integer literal
var obtained = JsonNumberValue.FromNumberLiteral("-1234567890");
// then
Assert.That(obtained, Is.Not.Null);
Assert.That(obtained.IsInteger, Is.True);
Assert.That(obtained.LongValue, Is.EqualTo(-1234567890));
}
public void FromNumberLiteralReturnsNullIfLiteralIsInvalid()
{
// when constructed with empty string
Assert.That(JsonNumberValue.FromNumberLiteral(""), Is.Null);
// when constructed with arbitrary string
Assert.That(JsonNumberValue.FromNumberLiteral("foobar"), Is.Null);
// when constructed with alpha-numeric string
Assert.That(JsonNumberValue.FromNumberLiteral("1234foo"), Is.Null);
}
public void NestedObjectInObjectJsonString()
{
// given
var jsonObjectDict = new Dictionary <string, JsonValue>();
jsonObjectDict.Add("Test", JsonBooleanValue.FromValue(false));
var jsonNestedObjectDict = new Dictionary <string, JsonValue>();
jsonNestedObjectDict.Add("Test3", JsonNumberValue.FromLong(1));
jsonObjectDict.Add("Test2", JsonObjectValue.FromDictionary(jsonNestedObjectDict));
Assert.That(JsonObjectValue.FromDictionary(jsonObjectDict).ToString(), Is.EqualTo("{\"Test\":false,\"Test2\":{\"Test3\":1}}"));
}
/// <summary>
/// Helper method for converting a simple JSON token to a JSON value.
/// </summary>
/// <param name="token">the token to convert to a JSON value</param>
/// <returns>the converted JSON value</returns>
private static JsonValue TokenToSimpleJsonValue(JsonToken token)
{
switch (token.TokenType)
{
case JsonTokenType.LITERAL_NULL:
return(JsonNullValue.Null);
case JsonTokenType.LITERAL_BOOLEAN:
return(JsonBooleanValue.FromLiteral(token.Value));
case JsonTokenType.VALUE_STRING:
return(JsonStringValue.FromString(token.Value));
case JsonTokenType.VALUE_NUMBER:
return(JsonNumberValue.FromNumberLiteral(token.Value));
default:
throw new JsonParserException($"Internal parser error: Unexpected JSON token \"{token}\"");
}
}
public void IntValueReturns32BitIntValue()
{
// when constructed from a long fitting into an int
Assert.That(JsonNumberValue.FromLong(int.MinValue).IntValue, Is.EqualTo(int.MinValue));
}
public void FloatValueReturns32BitFloatingPointValue()
{
// when
Assert.That(JsonNumberValue.FromDouble(Math.PI).FloatValue, Is.EqualTo(3.1415927410F));
}
public void DoubleJsonString()
{
Assert.That(JsonNumberValue.FromDouble(17.1).ToString(), Is.EqualTo("17.1"));
}
public void FromNumberLiteralReturnsNullIfLiteralIsNull()
{
// when
Assert.That(JsonNumberValue.FromNumberLiteral(null), Is.Null);
}
public void IsNumberType()
{
// then
Assert.That(JsonNumberValue.FromLong(0).ValueType, Is.EqualTo(JsonValueType.NUMBER));
}
public void LongJsonString()
{
Assert.That(JsonNumberValue.FromLong(17).ToString(), Is.EqualTo("17"));
}
public void LongValueReturnsValueWhenConstructedFromLong()
{
// when
Assert.That(JsonNumberValue.FromLong(-77129852519530769L).LongValue, Is.EqualTo(-77129852519530769L));
}
public void IntegerJsonString()
{
Assert.That(JsonNumberValue.FromNumberLiteral("17").ToString(), Is.EqualTo("17"));
}
