Esempio n. 1
0
        private static DecimalType ConvertFrom(object o)
        {
            var type = new DecimalType();

            type.SetValue(o);
            return(type);
        }
Esempio n. 2
0
        private static T ConvertTo <T>(DecimalType type)
        {
            if (type == null)
            {
                return(default(T));
            }

            return(type.GetValue <T>());
        }
Esempio n. 3
0
        public void BigDecimal_To_JavaBytes()
        {
            // arrange

            // act
            DecimalType actual = bigDecimal;

            // assert
            Assert.True(actual.ToBigEndian().SequenceEqual(javaByteOrder));
        }
Esempio n. 4
0
        public void Implicit_BigDecimal_Cast()
        {
            // arrange
            BigDecimal expected = bigDecimal;

            // act
            DecimalType actual = expected;

            // assert
            Assert.Equal(expected, (BigDecimal)actual);
        }
Esempio n. 5
0
        public void JavaBytes_To_BigDecimal()
        {
            // arrange

            // act
            DecimalType actual = new DecimalType();

            actual.SetValueFromBigEndian(javaByteOrder);

            // assert
            Assert.Equal(bigDecimal, (BigDecimal)actual);
        }
Esempio n. 6
0
        public void Operator_NotEqualTo()
        {
            // arrange
            var         value = bigDecimal;
            DecimalType type  = value;

            // act
            bool actual = !type.Equals(value);

            // assert
            Assert.False(actual);
        }
Esempio n. 7
0
        public void CassandraType_Cast()
        {
            // arrange
            BigDecimal  expected   = bigDecimal;
            DecimalType actualType = expected;

            // act
            CassandraObject actual = actualType;

            // assert
            Assert.Equal(expected, (BigDecimal)actual);
        }
Esempio n. 8
0
        public void Implicit_ByteArray_Cast()
        {
            // arrange
            byte[] expected = dotNetByteOrder;

            // act
            DecimalType actualType = expected;

            byte[] actual = actualType;

            // assert
            Assert.True(expected.SequenceEqual(actual));
        }