示例#1
0
        private static Value GetValue(ref JsonReader jsonReader)
        {
            int consumed;
            var value = new Value {
                Type = MapValueType(jsonReader.ValueType)
            };

            switch (value.Type)
            {
            case Value.ValueType.String:
                jsonReader.Encoder.TryDecode(jsonReader.Value, out string str, out consumed);
                value.StringValue = str;
                break;

            case Value.ValueType.Number:
                PrimitiveParser.TryParseDecimal(jsonReader.Value, out decimal num, out consumed, jsonReader.Encoder);
                value.NumberValue = Convert.ToDouble(num);
                break;

            case Value.ValueType.True:
                break;

            case Value.ValueType.False:
                break;

            case Value.ValueType.Null:
                break;

            case Value.ValueType.Object:
                value.ObjectValue = ReadObject(ref jsonReader);
                break;

            case Value.ValueType.Array:
                value.ArrayValue = ReadArray(ref jsonReader);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
            return(value);
        }
示例#2
0
        public unsafe void DecimalPositiveTests(string text, int length, decimal expectedValue, int expectedConsumed)
        {
            byte[] byteBuffer            = new Utf8String(text).CopyBytes();
            ReadOnlySpan <byte> byteSpan = new ReadOnlySpan <byte>(byteBuffer);

            char[] charBuffer            = text.ToCharArray();
            ReadOnlySpan <char> charSpan = new ReadOnlySpan <char>(charBuffer);

            bool    result;
            decimal actualValue;
            int     actualConsumed;

            result = PrimitiveParser.TryParseDecimal(byteSpan, out actualValue, out actualConsumed, TextEncoder.Utf8);

            Assert.True(result);
            Assert.Equal(expectedValue, actualValue);
            Assert.Equal(expectedConsumed, actualConsumed);

            fixed(byte *bytePointer = byteBuffer)
            {
                result = PrimitiveParser.InvariantUtf8.TryParseDecimal(bytePointer, length, out actualValue);

                Assert.True(result);
                Assert.Equal(expectedValue, actualValue);

                result = PrimitiveParser.InvariantUtf8.TryParseDecimal(bytePointer, length, out actualValue, out actualConsumed);

                Assert.True(result);
                Assert.Equal(expectedValue, actualValue);
                Assert.Equal(expectedConsumed, actualConsumed);
            }

            result = PrimitiveParser.InvariantUtf8.TryParseDecimal(byteSpan, out actualValue);

            Assert.True(result);
            Assert.Equal(expectedValue, actualValue);

            result = PrimitiveParser.InvariantUtf8.TryParseDecimal(byteSpan, out actualValue, out actualConsumed);

            Assert.True(result);
            Assert.Equal(expectedValue, actualValue);
            Assert.Equal(expectedConsumed, actualConsumed);

            ReadOnlySpan <byte> utf16ByteSpan = charSpan.AsBytes();

            result = PrimitiveParser.TryParseDecimal(utf16ByteSpan, out actualValue, out actualConsumed, TextEncoder.Utf16);
            Assert.True(result);
            Assert.Equal(expectedValue, actualValue);
            Assert.Equal(expectedConsumed, actualConsumed / 2);

            fixed(char *charPointer = charBuffer)
            {
                result = PrimitiveParser.InvariantUtf16.TryParseDecimal(charPointer, length, out actualValue);

                Assert.True(result);
                Assert.Equal(expectedValue, actualValue);

                result = PrimitiveParser.InvariantUtf16.TryParseDecimal(charPointer, length, out actualValue, out actualConsumed);

                Assert.True(result);
                Assert.Equal(expectedValue, actualValue);
                Assert.Equal(expectedConsumed, actualConsumed);
            }

            result = PrimitiveParser.InvariantUtf16.TryParseDecimal(charSpan, out actualValue);

            Assert.True(result);
            Assert.Equal(expectedValue, actualValue);

            result = PrimitiveParser.InvariantUtf16.TryParseDecimal(charSpan, out actualValue, out actualConsumed);

            Assert.True(result);
            Assert.Equal(expectedValue, actualValue);
            Assert.Equal(expectedConsumed, actualConsumed);
        }