private static void PrimitiveParserByteSpanToBool(string text)
        {
            bool value;
            int  bytesConsumed;

            byte[] utf8ByteArray             = Text.Encoding.UTF8.GetBytes(text);
            ReadOnlySpan <byte> utf8ByteSpan = new ReadOnlySpan <byte>(utf8ByteArray);

            foreach (var iteration in Benchmark.Iterations)
            {
                using (iteration.StartMeasurement())
                {
                    for (int i = 0; i < TestHelper.LoadIterations; i++)
                    {
                        Utf8Parser.TryParseBoolean(utf8ByteSpan, out value, out bytesConsumed);
                    }
                }
            }
        }
예제 #2
0
        public unsafe void BooleanPositiveTests(string text, int length, bool expectedValue, int expectedConsumed)
        {
            byte[] byteBuffer            = Text.Encoding.UTF8.GetBytes(text);
            ReadOnlySpan <byte> byteSpan = new ReadOnlySpan <byte>(byteBuffer);

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

            bool result;
            bool actualValue;
            int  actualConsumed;

            result = CustomParser.TryParseBoolean(byteSpan, out actualValue, out actualConsumed, SymbolTable.InvariantUtf8);

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

            //fixed (byte* bytePointer = byteBuffer)
            //{
            //    result = Parsers.Utf8.TryParseBoolean(bytePointer, length, out actualValue);

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

            //    result = Parsers.Utf8.TryParseBoolean(bytePointer, length, out actualValue, out actualConsumed);

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

            result = Utf8Parser.TryParseBoolean(byteSpan, out actualValue);

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

            result = Utf8Parser.TryParseBoolean(byteSpan, out actualValue, out actualConsumed);

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

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

            result = CustomParser.TryParseBoolean(utf16ByteSpan, out actualValue, out actualConsumed, SymbolTable.InvariantUtf16);
            Assert.True(result);
            Assert.Equal(expectedValue, actualValue);
            Assert.Equal(expectedConsumed, actualConsumed / 2);

            //fixed (char* charPointer = charBuffer)
            //{
            //    result = Parsers.Utf16.TryParseBoolean(charPointer, length, out actualValue);

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

            //    result = Parsers.Utf16.TryParseBoolean(charPointer, length, out actualValue, out actualConsumed);

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

            result = Utf16Parser.TryParseBoolean(charSpan, out actualValue);

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

            result = Utf16Parser.TryParseBoolean(charSpan, out actualValue, out actualConsumed);

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