コード例 #1
0
        public void BasicEncodingDecoding()
        {
            var bytes = new byte[byte.MaxValue + 1];

            for (int i = 0; i < byte.MaxValue + 1; i++)
            {
                bytes[i] = (byte)i;
            }

            for (int value = 0; value < 256; value++)
            {
                Span <byte> sourceBytes  = bytes.AsSpan().Slice(0, value + 1);
                Span <byte> encodedBytes = new byte[Base64Encoder.ComputeEncodedLength(sourceBytes.Length)];
                Assert.True(Base64Encoder.TryEncode(sourceBytes, encodedBytes, out int consumed, out int encodedBytesCount));
                Assert.Equal(encodedBytes.Length, encodedBytesCount);

                string encodedText  = Text.Encoding.ASCII.GetString(encodedBytes.ToArray());
                string expectedText = Convert.ToBase64String(bytes, 0, value + 1);
                Assert.Equal(expectedText, encodedText);

                if (encodedBytes.Length % 4 == 0)
                {
                    Span <byte> decodedBytes = new byte[Base64Encoder.ComputeDecodedLength(encodedBytes)];
                    Assert.True(Base64Encoder.TryDecode(encodedBytes, decodedBytes, out consumed, out int decodedByteCount));
                    Assert.Equal(sourceBytes.Length, decodedByteCount);
                    Assert.True(sourceBytes.SequenceEqual(decodedBytes));
                }
            }
        }
コード例 #2
0
        public void DecodeInPlace()
        {
            var list = new List <byte>();

            for (int value = 0; value < 256; value++)
            {
                list.Add((byte)value);
            }
            var testBytes = list.ToArray();

            for (int value = 0; value < 256; value++)
            {
                var sourceBytes = testBytes.AsSpan().Slice(0, value + 1);
                var buffer      = new byte[Base64Encoder.ComputeEncodedLength(sourceBytes.Length)];
                var bufferSlice = buffer.AsSpan();

                Base64Encoder.TryEncode(sourceBytes, bufferSlice, out int consumed, out int written);

                var encodedText  = Text.Encoding.ASCII.GetString(bufferSlice.ToArray());
                var expectedText = Convert.ToBase64String(testBytes, 0, value + 1);
                Assert.Equal(expectedText, encodedText);

                var decodedByteCount = Base64Encoder.DecodeInPlace(bufferSlice);
                Assert.Equal(sourceBytes.Length, decodedByteCount);

                for (int i = 0; i < decodedByteCount; i++)
                {
                    Assert.Equal(sourceBytes[i], buffer[i]);
                }
            }
        }
コード例 #3
0
        public void ComputeEncodedLength()
        {
            // (int.MaxValue - 4)/(4/3) => 1610612733, otherwise integer overflow
            int[] input    = { 0, 1, 2, 3, 4, 5, 6, 1610612728, 1610612729, 1610612730, 1610612731, 1610612732, 1610612733 };
            int[] expected = { 0, 4, 4, 4, 8, 8, 8, 2147483640, 2147483640, 2147483640, 2147483644, 2147483644, 2147483644 };
            for (int i = 0; i < input.Length; i++)
            {
                Assert.Equal(expected[i], Base64Encoder.ComputeEncodedLength(input[i]));
            }

            Assert.True(Base64Encoder.ComputeEncodedLength(1610612734) < 0);   // integer overflow
        }
コード例 #4
0
        private static void Base64EncodeBaseline(int numberOfBytes)
        {
            var source = new byte[numberOfBytes];

            InitalizeBytes(source.AsSpan());
            var destination = new char[Base64Encoder.ComputeEncodedLength(numberOfBytes)];

            foreach (var iteration in Benchmark.Iterations)
            {
                using (iteration.StartMeasurement()) {
                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
                    {
                        Convert.ToBase64CharArray(source, 0, source.Length, destination, 0);
                    }
                }
            }
        }
コード例 #5
0
        private static void Base64Encode(int numberOfBytes)
        {
            Span <byte> source = new byte[numberOfBytes];

            InitalizeBytes(source);
            Span <byte> destination = new byte[Base64Encoder.ComputeEncodedLength(numberOfBytes)];

            foreach (var iteration in Benchmark.Iterations)
            {
                using (iteration.StartMeasurement()) {
                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
                    {
                        Base64Encoder.TryEncode(source, destination, out int consumed, out int written);
                    }
                }
            }
        }
コード例 #6
0
        public void BasicEncoding()
        {
            var rnd = new Random(42);

            for (int i = 0; i < 10; i++)
            {
                int         numBytes = rnd.Next(100, 1000 * 1000);
                Span <byte> source   = new byte[numBytes];
                InitalizeBytes(source, numBytes);

                Span <byte> encodedBytes = new byte[Base64Encoder.ComputeEncodedLength(source.Length)];
                Assert.True(Base64Encoder.TryEncode(source, encodedBytes, out int consumed, out int encodedBytesCount));
                Assert.Equal(encodedBytes.Length, encodedBytesCount);

                string encodedText  = Text.Encoding.ASCII.GetString(encodedBytes.ToArray());
                string expectedText = Convert.ToBase64String(source.ToArray());
                Assert.Equal(expectedText, encodedText);
            }
        }
コード例 #7
0
        public void EncodingOutputTooSmall()
        {
            Span <byte> source = new byte[750];

            InitalizeBytes(source);

            int outputSize   = 320;
            int requiredSize = Base64Encoder.ComputeEncodedLength(source.Length);

            Span <byte> encodedBytes = new byte[outputSize];

            Assert.False(Base64Encoder.TryEncode(source, encodedBytes, out int consumed, out int written));
            Assert.Equal(encodedBytes.Length, written);
            Assert.Equal(encodedBytes.Length / 4 * 3, consumed);
            encodedBytes = new byte[requiredSize - outputSize];
            Assert.True(Base64Encoder.TryEncode(source.Slice(consumed), encodedBytes, out consumed, out written));
            Assert.Equal(encodedBytes.Length, written);
            Assert.Equal(encodedBytes.Length / 4 * 3, consumed);

            string encodedText  = Text.Encoding.ASCII.GetString(encodedBytes.ToArray());
            string expectedText = Convert.ToBase64String(source.ToArray()).Substring(outputSize);

            Assert.Equal(expectedText, encodedText);
        }