public void IsInstanceOfType_Null_Throws()
{
// arrange
var type = new FloatType();
// act
// assert
Assert.Throws <ArgumentNullException>(
() => type.IsInstanceOfType(null));
}
public void ParseLiteral_Null_Throws()
{
// arrange
var type = new FloatType();
// act
// assert
Assert.Throws <ArgumentNullException>(
() => type.ParseLiteral(null));
}
public void Serialize_Null()
{
// arrange
var type = new FloatType();
// act
var serializedValue = type.Serialize(null);
// assert
Assert.Null(serializedValue);
}
public void IsInstanceOfType_NullLiteral_True()
{
// arrange
var type = new FloatType();
// act
var result = type.IsInstanceOfType(NullValueNode.Default);
// assert
Assert.True(result);
}
public void EnsureFloatTypeKindIsCorret()
{
// arrange
FloatType type = new FloatType();
// act
TypeKind kind = type.Kind;
// assert
Assert.Equal(TypeKind.Scalar, type.Kind);
}
public void ParseValue_Wrong_Value_Throws()
{
// arrange
var type = new FloatType();
var value = "123";
// act
// assert
Assert.Throws <ScalarSerializationException>(
() => type.ParseValue(value));
}
public void IsInstanceOfType_FloatLiteral_True()
{
// arrange
var type = new FloatType();
// act
var result = type.IsInstanceOfType(CreateExponentialLiteral());
// assert
Assert.True(result);
}
public void ParseLiteral_Wrong_ValueNode_Throws()
{
// arrange
var type = new FloatType();
var input = new StringValueNode("abc");
// act
// assert
Assert.Throws <ScalarSerializationException>(
() => type.ParseLiteral(input));
}
public void Ensure_TypeKind_is_Scalar()
{
// arrange
var type = new FloatType();
// act
TypeKind kind = type.Kind;
// assert
Assert.Equal(TypeKind.Scalar, kind);
}
public void IsInstanceOfType_IntLiteral_True()
{
// arrange
var type = new FloatType();
// act
var result = type.IsInstanceOfType(new IntValueNode(123));
// assert
Assert.True(result);
}
public void ParseLiteral_NullValueNode()
{
// arrange
var type = new FloatType();
// act
var output = type.ParseLiteral(NullValueNode.Default);
// assert
Assert.Null(output);
}
public void IsInstanceOfType_StringLiteral_False()
{
// arrange
var type = new FloatType();
// act
var result = type.IsInstanceOfType(new StringValueNode("123"));
// assert
Assert.False(result);
}
public void Serialize_MaxValue_Violation()
{
// arrange
var type = new FloatType(0, 100);
double value = 123.456;
// act
// assert
Assert.Throws <ScalarSerializationException>(
() => type.Serialize(value));
}
public void Serialize_Wrong_Type_Throws()
{
// arrange
var type = new FloatType();
var input = "abc";
// act
// assert
Assert.Throws <ScalarSerializationException>(
() => type.Serialize(input));
}
public void ParseValue_MinValue_Violation()
{
// arrange
var type = new FloatType(1, 100);
double input = 0;
// act
Action action = () => type.ParseValue(input);
// assert
Assert.Throws <ScalarSerializationException>(action);
}
public void ParseValue_MinValue()
{
// arrange
var type = new FloatType(1, 100);
double input = 1;
// act
var literal = (FloatValueNode)type.ParseValue(input);
// assert
Assert.Equal(1, literal.ToDouble());
}
public void ParseLiteral_NullValueNode()
{
// arrange
FloatType type = new FloatType();
NullValueNode input = new NullValueNode();
// act
object output = type.ParseLiteral(input);
// assert
Assert.Null(output);
}
public void ParseValue_Nullable()
{
// arrange
var type = new FloatType();
double?input = 123;
// act
FloatValueNode output = (FloatValueNode)type.ParseValue(input);
// assert
Assert.Equal(123, output.ToDouble());
}
public void ParseValue_Null()
{
// arrange
var type = new FloatType();
object input = null;
// act
object output = type.ParseValue(input);
// assert
Assert.IsType <NullValueNode>(output);
}
public void Serialize_Type()
{
// arrange
var type = new FloatType();
double value = 123.456;
// act
var serializedValue = type.Serialize(value);
// assert
Assert.IsType <double>(serializedValue);
Assert.Equal(value, serializedValue);
}
public void ParseLiteral_FloatValueNode()
{
// arrange
FloatType type = new FloatType();
FloatValueNode input = new FloatValueNode("1.000000e+000");
// act
object output = type.ParseLiteral(input);
// assert
Assert.IsType <double>(output);
Assert.Equal(1.0d, output);
}
public void ParseLiteral_ExponentialLiteral()
{
// arrange
var type = new FloatType();
FloatValueNode literal = CreateExponentialLiteral();
// act
var value = type.ParseLiteral(literal);
// assert
Assert.IsType <double>(value);
Assert.Equal(literal.ToDouble(), value);
}
public void ParseLiteral_IntLiteral()
{
// arrange
var type = new FloatType();
var literal = new IntValueNode(123);
// act
var value = type.ParseLiteral(literal);
// assert
Assert.IsType <double>(value);
Assert.Equal(literal.ToDouble(), value);
}
public void Serialize_Double()
{
// arrange
FloatType type = new FloatType();
double input = 1.0d;
// act
object serializedValue = type.Serialize(input);
// assert
Assert.IsType <double>(serializedValue);
Assert.Equal(1.0d, serializedValue);
}
public void Serialize_Float()
{
// arrange
FloatType type = new FloatType();
float input = 1.0f;
// act
object serializedValue = type.Serialize(input);
// assert
Assert.IsType <float>(serializedValue);
Assert.Equal(1.0f, serializedValue);
}
public void ParseValue_Double()
{
// arrange
FloatType type = new FloatType();
double input = 1.0d;
string expectedLiteralValue = "1.000000e+000";
// act
FloatValueNode literal =
(FloatValueNode)type.ParseValue(input);
// assert
Assert.Equal(expectedLiteralValue, literal.Value);
}