Esempio n. 1
0
        public void IsInstanceOfType_Null_Throws()
        {
            // arrange
            var type = new FloatType();

            // act
            // assert
            Assert.Throws <ArgumentNullException>(
                () => type.IsInstanceOfType(null));
        }
Esempio n. 2
0
        public void ParseLiteral_Null_Throws()
        {
            // arrange
            var type = new FloatType();

            // act
            // assert
            Assert.Throws <ArgumentNullException>(
                () => type.ParseLiteral(null));
        }
Esempio n. 3
0
        public void Serialize_Null()
        {
            // arrange
            var type = new FloatType();

            // act
            var serializedValue = type.Serialize(null);

            // assert
            Assert.Null(serializedValue);
        }
Esempio n. 4
0
        public void IsInstanceOfType_NullLiteral_True()
        {
            // arrange
            var type = new FloatType();

            // act
            var result = type.IsInstanceOfType(NullValueNode.Default);

            // assert
            Assert.True(result);
        }
Esempio n. 5
0
        public void EnsureFloatTypeKindIsCorret()
        {
            // arrange
            FloatType type = new FloatType();

            // act
            TypeKind kind = type.Kind;

            // assert
            Assert.Equal(TypeKind.Scalar, type.Kind);
        }
Esempio n. 6
0
        public void ParseValue_Wrong_Value_Throws()
        {
            // arrange
            var type  = new FloatType();
            var value = "123";

            // act
            // assert
            Assert.Throws <ScalarSerializationException>(
                () => type.ParseValue(value));
        }
Esempio n. 7
0
        public void IsInstanceOfType_FloatLiteral_True()
        {
            // arrange
            var type = new FloatType();

            // act
            var result = type.IsInstanceOfType(CreateExponentialLiteral());

            // assert
            Assert.True(result);
        }
Esempio n. 8
0
        public void ParseLiteral_Wrong_ValueNode_Throws()
        {
            // arrange
            var type  = new FloatType();
            var input = new StringValueNode("abc");

            // act
            // assert
            Assert.Throws <ScalarSerializationException>(
                () => type.ParseLiteral(input));
        }
Esempio n. 9
0
        public void Ensure_TypeKind_is_Scalar()
        {
            // arrange
            var type = new FloatType();

            // act
            TypeKind kind = type.Kind;

            // assert
            Assert.Equal(TypeKind.Scalar, kind);
        }
Esempio n. 10
0
        public void IsInstanceOfType_IntLiteral_True()
        {
            // arrange
            var type = new FloatType();

            // act
            var result = type.IsInstanceOfType(new IntValueNode(123));

            // assert
            Assert.True(result);
        }
Esempio n. 11
0
        public void ParseLiteral_NullValueNode()
        {
            // arrange
            var type = new FloatType();

            // act
            var output = type.ParseLiteral(NullValueNode.Default);

            // assert
            Assert.Null(output);
        }
Esempio n. 12
0
        public void IsInstanceOfType_StringLiteral_False()
        {
            // arrange
            var type = new FloatType();

            // act
            var result = type.IsInstanceOfType(new StringValueNode("123"));

            // assert
            Assert.False(result);
        }
Esempio n. 13
0
        public void Serialize_MaxValue_Violation()
        {
            // arrange
            var    type  = new FloatType(0, 100);
            double value = 123.456;

            // act
            // assert
            Assert.Throws <ScalarSerializationException>(
                () => type.Serialize(value));
        }
Esempio n. 14
0
        public void Serialize_Wrong_Type_Throws()
        {
            // arrange
            var type  = new FloatType();
            var input = "abc";

            // act
            // assert
            Assert.Throws <ScalarSerializationException>(
                () => type.Serialize(input));
        }
Esempio n. 15
0
        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);
        }
Esempio n. 16
0
        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());
        }
Esempio n. 17
0
        public void ParseLiteral_NullValueNode()
        {
            // arrange
            FloatType     type  = new FloatType();
            NullValueNode input = new NullValueNode();

            // act
            object output = type.ParseLiteral(input);

            // assert
            Assert.Null(output);
        }
Esempio n. 18
0
        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());
        }
Esempio n. 19
0
        public void ParseValue_Null()
        {
            // arrange
            var    type  = new FloatType();
            object input = null;

            // act
            object output = type.ParseValue(input);

            // assert
            Assert.IsType <NullValueNode>(output);
        }
Esempio n. 20
0
        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);
        }
Esempio n. 21
0
        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);
        }
Esempio n. 22
0
        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);
        }
Esempio n. 23
0
        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);
        }
Esempio n. 24
0
        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);
        }
Esempio n. 25
0
        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);
        }
Esempio n. 26
0
        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);
        }