Example #1
0
        public void Bug520719()
        {
            // the following test should pass without Assert() in debug version.

            var int8 = new SByteValue();

            int8.InnerText = "+10";
            Assert.Equal(10, int8.Value);
            Assert.Equal("+10", int8.InnerText);

            var int16 = new Int16Value();

            int16.InnerText = "+10";
            Assert.Equal(10, int16.Value);
            Assert.Equal("+10", int16.InnerText);

            var int32 = new Int32Value();

            int32.InnerText = "+10";
            Assert.Equal(10, int32.Value);
            Assert.Equal("+10", int32.InnerText);

            var int64 = new Int64Value();

            int64.InnerText = "+10";
            Assert.Equal(10, int64.Value);
            Assert.Equal("+10", int64.InnerText);

            var integer = new IntegerValue();

            integer.InnerText = "+10";
            Assert.Equal(10, integer.Value);
            Assert.Equal("+10", integer.InnerText);

            var dec = new DecimalValue();

            dec.InnerText = "+10";
            Assert.Equal(10, dec.Value);
            Assert.Equal("+10", dec.InnerText);

            var single = new SingleValue();

            single.InnerText = "+10";
            Assert.Equal(10, single.Value);
            Assert.Equal("+10", single.InnerText);

            var dble = new DoubleValue();

            dble.InnerText = "+10";
            Assert.Equal(10, dble.Value);
            Assert.Equal("+10", dble.InnerText);
        }
Example #2
0
 public override int GetHashCode()
 {
     unchecked
     {
         var hashCode = CharValue.GetHashCode();
         hashCode = (hashCode * 397) ^ ByteValue.GetHashCode();
         hashCode = (hashCode * 397) ^ SByteValue.GetHashCode();
         hashCode = (hashCode * 397) ^ ShortValue.GetHashCode();
         hashCode = (hashCode * 397) ^ UShortValue.GetHashCode();
         hashCode = (hashCode * 397) ^ IntValue;
         hashCode = (hashCode * 397) ^ (int)UIntValue;
         hashCode = (hashCode * 397) ^ LongValue.GetHashCode();
         hashCode = (hashCode * 397) ^ ULongValue.GetHashCode();
         hashCode = (hashCode * 397) ^ FloatValue.GetHashCode();
         hashCode = (hashCode * 397) ^ DoubleValue.GetHashCode();
         hashCode = (hashCode * 397) ^ DecimalValue.GetHashCode();
         hashCode = (hashCode * 397) ^ DateTimeValue.GetHashCode();
         hashCode = (hashCode * 397) ^ GuidValue.GetHashCode();
         hashCode = (hashCode * 397) ^ StringValue.GetHashCode();
         return(hashCode);
     }
 }
Example #3
0
        public void OpenXmlSimpleTypeConverterTest()
        {
            // 1. Base64BinaryValue
            Base64BinaryValue base64 = new Base64BinaryValue();

            base64 = "AA3322";
            Assert.True(base64 == "AA3322");
            Assert.Equal("AA3322", base64.Value);
            base64 = Base64BinaryValue.FromString("1234");
            Assert.Equal("1234", base64.ToString());
            Assert.Equal("1234", Base64BinaryValue.ToString(base64));

            // 2. BooleanValue
            BooleanValue booleanValue = new BooleanValue();

            booleanValue = true;
            Assert.True(booleanValue);
            Assert.True(booleanValue.Value);
            booleanValue = BooleanValue.FromBoolean(false);
            Assert.False(booleanValue);
            Assert.False(BooleanValue.ToBoolean(booleanValue));

            // 3. ByteValue
            ByteValue byteValue = new ByteValue();
            byte      bt        = 1;

            byteValue = bt;
            Assert.True(bt == byteValue);
            Assert.Equal(bt, byteValue.Value);
            bt        = 2;
            byteValue = ByteValue.FromByte(bt);
            Assert.Equal(bt, ByteValue.ToByte(byteValue));

            // 4. DateTimeValue
            DateTimeValue dtValue = new DateTimeValue();
            DateTime      dt      = DateTime.Now;

            dtValue = dt;
            Assert.True(dt == dtValue);
            dt      = DateTime.Now.AddDays(1);
            dtValue = DateTimeValue.FromDateTime(dt);
            Assert.Equal(dt, dtValue.Value);
            Assert.Equal(dt, DateTimeValue.ToDateTime(dt));

            // 5. DecimalValue
            DecimalValue decimalValue = new DecimalValue();
            decimal      dcm          = 10;

            decimalValue = dcm;
            Assert.True(dcm == decimalValue);
            decimalValue = DecimalValue.FromDecimal(20);
            Assert.Equal(20, decimalValue.Value);
            Assert.Equal(20, DecimalValue.ToDecimal(decimalValue));

            // 6. DoubleValue
            DoubleValue doubleValue = new DoubleValue();
            double      dbl         = 1.1;

            doubleValue = dbl;
            Assert.True(dbl == doubleValue);
            doubleValue = DoubleValue.FromDouble(2.2);
            Assert.Equal(2.2, doubleValue.Value);
            Assert.Equal(2.2, DoubleValue.ToDouble(doubleValue));

            // 7. HexBinaryValue
            HexBinaryValue hexBinaryValue = new HexBinaryValue();
            string         hex            = "0X99CCFF";

            hexBinaryValue = hex;
            Assert.True(hex == hexBinaryValue);
            hex            = "111111";
            hexBinaryValue = HexBinaryValue.FromString(hex);
            Assert.Equal(hex, hexBinaryValue.Value);
            Assert.Equal(hex, HexBinaryValue.ToString(hexBinaryValue));

            // 8. Int16
            Int16Value int16Value = new Int16Value();
            short      int16      = 16;

            int16Value = int16;
            Assert.True(int16 == int16Value);
            int16      = 17;
            int16Value = Int16Value.FromInt16(int16);
            Assert.Equal(int16, int16Value.Value);
            Assert.Equal(int16, Int16Value.ToInt16(int16Value));

            // 9. Int32
            Int32Value int32Value = new Int32Value();
            int        int32      = 32;

            int32Value = int32;
            Assert.True(int32 == int32Value);
            int32      = 33;
            int32Value = Int32Value.FromInt32(int32);
            Assert.Equal(int32, int32Value.Value);
            Assert.Equal(int32, Int32Value.ToInt32(int32Value));

            // 10. Int64
            Int64Value int64Value = new Int64Value();
            long       int64      = 64;

            int64Value = int64;
            Assert.True(int64 == int64Value);
            int64      = 17;
            int64Value = Int64Value.FromInt64(int64);
            Assert.Equal(int64, int64Value.Value);
            Assert.Equal(int64, Int64Value.ToInt64(int64Value));

            // 11. IntegerValue
            IntegerValue integerValue = new IntegerValue();
            int          integer      = 64;

            integerValue = integer;
            Assert.True(integer == integerValue);
            integer      = 17;
            integerValue = IntegerValue.FromInt64(integer);
            Assert.Equal(integer, integerValue.Value);
            Assert.Equal(integer, IntegerValue.ToInt64(integerValue));

            // 12. OnOffValue
            OnOffValue onOffValue = new OnOffValue();

            onOffValue = true;
            Assert.True(onOffValue);
            onOffValue = OnOffValue.FromBoolean(false);
            Assert.False(onOffValue.Value);
            Assert.False(OnOffValue.ToBoolean(onOffValue));

            // 13. SByteValue
            SByteValue sbyteValue = new SByteValue();
            sbyte      sbt        = sbyte.MaxValue;

            sbyteValue = sbt;
            Assert.True(sbt == sbyteValue);
            sbt        = sbyte.MinValue;
            sbyteValue = SByteValue.FromSByte(sbt);
            Assert.Equal(sbt, sbyteValue.Value);
            Assert.Equal(sbt, SByteValue.ToSByte(sbt));

            // 14. SingleValue
            SingleValue singleValue = new SingleValue();
            float       single      = float.MaxValue;

            singleValue = single;
            Assert.True(single == singleValue);
            single      = float.NaN;
            singleValue = SingleValue.FromSingle(single);
            Assert.Equal(single, singleValue.Value);
            Assert.Equal(single, SingleValue.ToSingle(singleValue));

            // 15. StringValue
            StringValue stringValue = new StringValue();
            string      str         = "Ethan";

            stringValue = str;
            Assert.True(str == stringValue);
            str         = "Yin";
            stringValue = StringValue.FromString(str);
            Assert.Equal(str, stringValue.Value);
            Assert.Equal(str, stringValue.ToString());
            Assert.Equal(str, StringValue.ToString(stringValue));

            // 16. TrueFalseBlankValue
            TrueFalseBlankValue tfbValue = new TrueFalseBlankValue();

            tfbValue = true;
            Assert.True(tfbValue);
            tfbValue = TrueFalseBlankValue.FromBoolean(false);
            Assert.False(tfbValue.Value);
            Assert.False(TrueFalseBlankValue.ToBoolean(tfbValue));

            // 17. TrueFalseValue
            TrueFalseValue tfValue = new TrueFalseValue();

            tfValue = true;
            Assert.True(tfValue);
            tfValue = TrueFalseValue.FromBoolean(false);
            Assert.False(tfValue.Value);
            Assert.False(TrueFalseValue.ToBoolean(tfValue));

            // 18. UInt16Value
            UInt16Value uint16Value = new UInt16Value();
            ushort      uint16      = ushort.MaxValue;

            uint16Value = uint16;
            Assert.True(uint16 == uint16Value);
            uint16      = ushort.MinValue;
            uint16Value = UInt16Value.FromUInt16(uint16);
            Assert.Equal(uint16, uint16Value.Value);
            Assert.Equal(uint16, UInt16Value.ToUInt16(uint16Value));

            // 19. UInt32Value
            UInt32Value uint32Value = new UInt32Value();
            uint        uint32      = uint.MaxValue;

            uint32Value = uint32;
            Assert.True(uint32 == uint32Value);
            uint32      = uint.MinValue;
            uint32Value = UInt32Value.FromUInt32(uint32);
            Assert.Equal(uint32, uint32Value.Value);
            Assert.Equal(uint32, UInt32Value.ToUInt32(uint32Value));

            // 20. UInt64Value
            UInt64Value uint64Value = new UInt64Value();
            ulong       uint64      = ulong.MaxValue;

            uint64Value = uint64;
            Assert.True(uint64 == uint64Value);
            uint64      = ulong.MinValue;
            uint64Value = UInt64Value.FromUInt64(uint64);
            Assert.Equal(uint64, uint64Value.Value);
            Assert.Equal(uint64, UInt64Value.ToUInt64(uint64Value));
        }
        public void TestAssertInInnerTextForPlusSymbol()
        {
            this.MyTestInitialize(TestContext.GetCurrentMethod());

            // same issue for SByteValue, Int16Value, IntegerValue, DecimalValue, SingleValue, DoubleValue
            {
                var v = new SByteValue();
                v.InnerText = "+100";
                sbyte  v2 = v.Value;
                string t  = v.InnerText;

                // Verify value and text
                Log.VerifyValue(v2, (sbyte)100, "{0}.Value", v.GetType().Name);
                Log.VerifyValue(t, "+100", "{0}.InnerText", v.GetType().Name);
            }

            {
                var v = new Int16Value();
                v.InnerText = "+100";
                Int16  v2 = v.Value;
                string t  = v.InnerText;

                // Verify value and text
                Log.VerifyValue(v2, (Int16)100, "{0}.Value", v.GetType().Name);
                Log.VerifyValue(t, "+100", "{0}.InnerText", v.GetType().Name);
            }

            {
                var v = new Int32Value();
                v.InnerText = "+100";
                int    v2 = v.Value;
                string t  = v.InnerText;

                // Verify value and text
                Log.VerifyValue(v2, (int)100, "{0}.Value", v.GetType().Name);
                Log.VerifyValue(t, "+100", "{0}.InnerText", v.GetType().Name);
            }

            {
                var v = new IntegerValue();
                v.InnerText = "+100";
                long   v2 = v.Value;
                string t  = v.InnerText;

                // Verify value and text
                Log.VerifyValue(v2, (long)100, "{0}.Value", v.GetType().Name);
                Log.VerifyValue(t, "+100", "{0}.InnerText", v.GetType().Name);
            }

            {
                var v = new DecimalValue();
                v.InnerText = "+100";
                decimal v2 = v.Value;
                string  t  = v.InnerText;

                // Verify value and text
                Log.VerifyValue(v2, (decimal)100, "{0}.Value", v.GetType().Name);
                Log.VerifyValue(t, "+100", "{0}.InnerText", v.GetType().Name);
            }

            {
                var v = new SingleValue();
                v.InnerText = "+100";
                float  v2 = v.Value;
                string t  = v.InnerText;

                // Verify value and text
                Log.VerifyValue(v2, (float)100, "{0}.Value", v.GetType().Name);
                Log.VerifyValue(t, "+100", "{0}.InnerText", v.GetType().Name);
            }

            {
                var v = new DoubleValue();
                v.InnerText = "+100";
                double v2 = v.Value;
                string t  = v.InnerText;

                // Verify value and text
                Log.VerifyValue(v2, (double)100, "{0}.Value", v.GetType().Name);
                Log.VerifyValue(t, "+100", "{0}.InnerText", v.GetType().Name);
            }
        }
Example #5
0
        public void TestAssertInInnerTextForPlusSymbol()
        {
            // same issue for SByteValue, Int16Value, IntegerValue, DecimalValue, SingleValue, DoubleValue
            {
                var v = new SByteValue();
                v.InnerText = "+100";
                sbyte  v2 = v.Value;
                string t  = v.InnerText;

                // Verify value and text
                Log.VerifyValue(v2, (sbyte)100, "{0}.Value", v.GetType().Name);
                Log.VerifyValue(t, "+100", "{0}.InnerText", v.GetType().Name);
            }

            {
                var v = new Int16Value();
                v.InnerText = "+100";
                short  v2 = v.Value;
                string t  = v.InnerText;

                // Verify value and text
                Log.VerifyValue(v2, (short)100, "{0}.Value", v.GetType().Name);
                Log.VerifyValue(t, "+100", "{0}.InnerText", v.GetType().Name);
            }

            {
                var v = new Int32Value();
                v.InnerText = "+100";
                int    v2 = v.Value;
                string t  = v.InnerText;

                // Verify value and text
                Log.VerifyValue(v2, 100, "{0}.Value", v.GetType().Name);
                Log.VerifyValue(t, "+100", "{0}.InnerText", v.GetType().Name);
            }

            {
                var v = new IntegerValue();
                v.InnerText = "+100";
                long   v2 = v.Value;
                string t  = v.InnerText;

                // Verify value and text
                Log.VerifyValue(v2, 100L, "{0}.Value", v.GetType().Name);
                Log.VerifyValue(t, "+100", "{0}.InnerText", v.GetType().Name);
            }

            {
                var v = new DecimalValue();
                v.InnerText = "+100";
                decimal v2 = v.Value;
                string  t  = v.InnerText;

                // Verify value and text
                Log.VerifyValue(v2, 100M, "{0}.Value", v.GetType().Name);
                Log.VerifyValue(t, "+100", "{0}.InnerText", v.GetType().Name);
            }

            {
                var v = new SingleValue();
                v.InnerText = "+100";
                float  v2 = v.Value;
                string t  = v.InnerText;

                // Verify value and text
                Log.VerifyValue(v2, 100F, "{0}.Value", v.GetType().Name);
                Log.VerifyValue(t, "+100", "{0}.InnerText", v.GetType().Name);
            }

            {
                var v = new DoubleValue();
                v.InnerText = "+100";
                double v2 = v.Value;
                string t  = v.InnerText;

                // Verify value and text
                Log.VerifyValue(v2, 100D, "{0}.Value", v.GetType().Name);
                Log.VerifyValue(t, "+100", "{0}.InnerText", v.GetType().Name);
            }
        }
        public void Bug520719()
        {
            // the following test should pass without Assert() in debug version.
            
            var int8 = new SByteValue();
            int8.InnerText = "+10";
            Assert.Equal(10, int8.Value);
            Assert.Equal("+10", int8.InnerText);

            var int16 = new Int16Value();
            int16.InnerText = "+10";
            Assert.Equal(10, int16.Value);
            Assert.Equal("+10", int16.InnerText);

            var int32 = new Int32Value();
            int32.InnerText = "+10";
            Assert.Equal(10, int32.Value);
            Assert.Equal("+10", int32.InnerText);

            var int64 = new Int64Value();
            int64.InnerText = "+10";
            Assert.Equal(10, int64.Value);
            Assert.Equal("+10", int64.InnerText);

            var integer = new IntegerValue();
            integer.InnerText = "+10";
            Assert.Equal(10, integer.Value);
            Assert.Equal("+10", integer.InnerText);

            var dec = new DecimalValue();
            dec.InnerText = "+10";
            Assert.Equal(10, dec.Value);
            Assert.Equal("+10", dec.InnerText);

            var single = new SingleValue();
            single.InnerText = "+10";
            Assert.Equal(10, single.Value);
            Assert.Equal("+10", single.InnerText);

            var dble = new DoubleValue();
            dble.InnerText = "+10";
            Assert.Equal(10, dble.Value);
            Assert.Equal("+10", dble.InnerText);
        }
        public void OpenXmlSimpleTypeConverterTest()
        {
            // 1. Base64BinaryValue
            Base64BinaryValue base64 = new Base64BinaryValue();
            base64 = "AA3322";
            Assert.True("AA3322" == base64);
            Assert.Equal("AA3322", base64.Value);
            base64 = Base64BinaryValue.FromString("1234");
            Assert.Equal("1234", base64.ToString());
            Assert.Equal("1234", Base64BinaryValue.ToString(base64));

            // 2. BooleanValue
            BooleanValue booleanValue = new BooleanValue();
            booleanValue = true;
            Assert.True(booleanValue);
            Assert.True(booleanValue.Value);
            booleanValue = BooleanValue.FromBoolean(false);
            Assert.False(booleanValue);
            Assert.Equal(false, BooleanValue.ToBoolean(booleanValue));

            // 3. ByteValue
            ByteValue byteValue = new ByteValue();
            Byte bt = 1;
            byteValue = bt;
            Assert.True(bt == byteValue);
            Assert.Equal(bt, byteValue.Value);
            bt = 2;
            byteValue = ByteValue.FromByte(bt);
            Assert.Equal(bt, ByteValue.ToByte(byteValue));

            // 4. DateTimeValue
            DateTimeValue dtValue = new DateTimeValue();
            DateTime dt = DateTime.Now;
            dtValue = dt;
            Assert.True(dt == dtValue);
            dt = DateTime.Now.AddDays(1);
            dtValue = DateTimeValue.FromDateTime(dt);
            Assert.Equal(dt, dtValue.Value);
            Assert.Equal(dt, DateTimeValue.ToDateTime(dt));

            // 5. DecimalValue
            DecimalValue decimalValue = new DecimalValue();
            decimal dcm = 10;
            decimalValue = dcm;
            Assert.True(dcm == decimalValue);
            decimalValue = DecimalValue.FromDecimal(20);
            Assert.Equal(20, decimalValue.Value);
            Assert.Equal(20, DecimalValue.ToDecimal(decimalValue));

            // 6. DoubleValue
            DoubleValue doubleValue = new DoubleValue();
            double dbl = 1.1;
            doubleValue = dbl;
            Assert.True(dbl == doubleValue);
            doubleValue = DoubleValue.FromDouble(2.2);
            Assert.Equal(2.2, doubleValue.Value);
            Assert.Equal(2.2, DoubleValue.ToDouble(doubleValue));

            // 7. HexBinaryValue
            HexBinaryValue hexBinaryValue = new HexBinaryValue();
            string hex = "0X99CCFF";
            hexBinaryValue = hex;
            Assert.True(hex == hexBinaryValue);
            hex = "111111";
            hexBinaryValue = HexBinaryValue.FromString(hex);
            Assert.Equal(hex, hexBinaryValue.Value);
            Assert.Equal(hex, HexBinaryValue.ToString(hexBinaryValue));

            // 8. Int16
            Int16Value int16Value = new Int16Value();
            Int16 int16 = 16;
            int16Value = int16;
            Assert.True(int16 == int16Value);
            int16 = 17;
            int16Value = Int16Value.FromInt16(int16);
            Assert.Equal(int16, int16Value.Value);
            Assert.Equal(int16, Int16Value.ToInt16(int16Value));

            // 9. Int32
            Int32Value int32Value = new Int32Value();
            Int32 int32 = 32;
            int32Value = int32;
            Assert.True(int32 == int32Value);
            int32 = 33;
            int32Value = Int32Value.FromInt32(int32);
            Assert.Equal(int32, int32Value.Value);
            Assert.Equal(int32, Int32Value.ToInt32(int32Value));

            // 10. Int64
            Int64Value int64Value = new Int64Value();
            Int64 int64 = 64;
            int64Value = int64;
            Assert.True(int64 == int64Value);
            int64 = 17;
            int64Value = Int64Value.FromInt64(int64);
            Assert.Equal(int64, int64Value.Value);
            Assert.Equal(int64, Int64Value.ToInt64(int64Value));

            // 11. IntegerValue
            IntegerValue integerValue = new IntegerValue();
            int integer = 64;
            integerValue = integer;
            Assert.True(integer == integerValue);
            integer = 17;
            integerValue = IntegerValue.FromInt64(integer);
            Assert.Equal(integer, integerValue.Value);
            Assert.Equal(integer, IntegerValue.ToInt64(integerValue));

            // 12. OnOffValue
            OnOffValue onOffValue = new OnOffValue();
            onOffValue = true;
            Assert.True(onOffValue);
            onOffValue = OnOffValue.FromBoolean(false);
            Assert.Equal(false, onOffValue.Value);
            Assert.Equal(false, OnOffValue.ToBoolean(onOffValue));

            // 13. SByteValue
            SByteValue sbyteValue = new SByteValue();
            SByte sbt = SByte.MaxValue;
            sbyteValue = sbt;
            Assert.True(sbt == sbyteValue);
            sbt = SByte.MinValue;
            sbyteValue = SByteValue.FromSByte(sbt);
            Assert.Equal(sbt, sbyteValue.Value);
            Assert.Equal(sbt, SByteValue.ToSByte(sbt));

            // 14. SingleValue
            SingleValue singleValue = new SingleValue();
            Single single = Single.MaxValue;
            singleValue = single;
            Assert.True(single == singleValue);
            single = Single.NaN;
            singleValue = SingleValue.FromSingle(single);
            Assert.Equal(single, singleValue.Value);
            Assert.Equal(single, SingleValue.ToSingle(singleValue));

            // 15. StringValue
            StringValue stringValue = new StringValue();
            String str = "Ethan";
            stringValue = str;
            Assert.True(str == stringValue);
            str = "Yin";
            stringValue = StringValue.FromString(str);
            Assert.Equal(str, stringValue.Value);
            Assert.Equal(str, stringValue.ToString());
            Assert.Equal(str, StringValue.ToString(stringValue));

            // 16. TrueFalseBlankValue
            TrueFalseBlankValue tfbValue = new TrueFalseBlankValue();
            tfbValue = true;
            Assert.True(tfbValue);
            tfbValue = TrueFalseBlankValue.FromBoolean(false);
            Assert.Equal(false, tfbValue.Value);
            Assert.Equal(false, TrueFalseBlankValue.ToBoolean(tfbValue));

            // 17. TrueFalseValue
            TrueFalseValue tfValue = new TrueFalseValue();
            tfValue = true;
            Assert.True(tfValue);
            tfValue = TrueFalseValue.FromBoolean(false);
            Assert.Equal(false, tfValue.Value);
            Assert.Equal(false, TrueFalseValue.ToBoolean(tfValue));

            // 18. UInt16Value
            UInt16Value uint16Value = new UInt16Value();
            UInt16 uint16 = UInt16.MaxValue;
            uint16Value = uint16;
            Assert.True(uint16 == uint16Value);
            uint16 = UInt16.MinValue;
            uint16Value = UInt16Value.FromUInt16(uint16);
            Assert.Equal(uint16, uint16Value.Value);
            Assert.Equal(uint16, UInt16Value.ToUInt16(uint16Value));

            // 19. UInt32Value
            UInt32Value uint32Value = new UInt32Value();
            UInt32 uint32 = UInt32.MaxValue;
            uint32Value = uint32;
            Assert.True(uint32 == uint32Value);
            uint32 = UInt32.MinValue;
            uint32Value = UInt32Value.FromUInt32(uint32);
            Assert.Equal(uint32, uint32Value.Value);
            Assert.Equal(uint32, UInt32Value.ToUInt32(uint32Value));

            // 20. UInt64Value
            UInt64Value uint64Value = new UInt64Value();
            UInt64 uint64 = UInt64.MaxValue;
            uint64Value = uint64;
            Assert.True(uint64 == uint64Value);
            uint64 = UInt64.MinValue;
            uint64Value = UInt64Value.FromUInt64(uint64);
            Assert.Equal(uint64, uint64Value.Value);
            Assert.Equal(uint64, UInt64Value.ToUInt64(uint64Value));
        }
 public SByteValueTests()
 {
     SmallValue1 = new SByteValue((sbyte)10);
     SmallValue2 = new SByteValue((sbyte)10);
     LargeValue  = new SByteValue((sbyte)20);
 }