private static void Base64Decode(int numberOfBytes)
{
Span <byte> source = new byte[numberOfBytes];
Base64TestHelper.InitalizeBytes(source);
Span <byte> encoded = new byte[Base64.BytesToUtf8Length(numberOfBytes)];
Base64.BytesToUtf8(source, encoded, out int consumed, out int written);
foreach (var iteration in Benchmark.Iterations)
{
using (iteration.StartMeasurement()) {
for (int i = 0; i < Benchmark.InnerIterationCount; i++)
{
Base64.Utf8ToBytes(encoded, source, out int bytesConsumed, out int bytesWritten);
}
}
}
}
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];
Base64TestHelper.InitalizeBytes(source, numBytes);
Span <byte> encodedBytes = new byte[Base64.ComputeEncodedLength(source.Length)];
Assert.Equal(TransformationStatus.Done, Base64.Encoder.Transform(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);
}
}
private static void Base64DecodeInPlace(int numberOfBytes)
{
Span <byte> source = new byte[numberOfBytes];
Base64TestHelper.InitalizeBytes(source);
int length = Base64.ComputeEncodedLength(numberOfBytes);
foreach (var iteration in Benchmark.Iterations)
{
using (iteration.StartMeasurement())
{
for (int i = 0; i < Benchmark.InnerIterationCount; i++)
{
Span <byte> encodedSpan = new byte[length];
Base64.Encoder.Transform(source, encodedSpan, out int consumed, out int written);
Base64.DecodeInPlace(encodedSpan, out int bytesConsumed, out int bytesWritten);
}
}
}
}
[InlineData(30000, 50000)] // No Third Call
private static void StichingTestStichingRequired(int stackSize, int inputBufferSize)
{
Span <byte> source = new byte[inputBufferSize];
Base64TestHelper.InitalizeDecodableBytes(source);
Span <byte> expected = new byte[inputBufferSize];
Base64.Decoder.Transform(source, expected, out int expectedConsumed, out int expectedWritten);
Base64TestHelper.SplitSourceIntoSpans(source, true, out ReadOnlySpan <byte> source1, out ReadOnlySpan <byte> source2);
Span <byte> destination = new byte[inputBufferSize]; // Plenty of space
Span <byte> stackSpan;
unsafe
{
byte *stackBytes = stackalloc byte[stackSize];
stackSpan = new Span <byte>(stackBytes, stackSize);
}
int bytesConsumed = 0;
int bytesWritten = 0;
foreach (var iteration in Benchmark.Iterations)
{
using (iteration.StartMeasurement())
{
for (int i = 0; i < Benchmark.InnerIterationCount; i++)
{
Base64TestHelper.DecodeStichUsingStack(source1, source2, destination, stackSpan, out bytesConsumed, out bytesWritten);
}
}
}
Assert.Equal(expectedConsumed, bytesConsumed);
Assert.Equal(expectedWritten, bytesWritten);
Assert.True(expected.SequenceEqual(destination));
}
public void BasicDecoding()
{
var rnd = new Random(42);
for (int i = 0; i < 10; i++)
{
int numBytes = rnd.Next(100, 1000 * 1000);
while (numBytes % 4 != 0)
{
numBytes = rnd.Next(100, 1000 * 1000);
}
Span <byte> source = new byte[numBytes];
Base64TestHelper.InitalizeDecodableBytes(source, numBytes);
Span <byte> decodedBytes = new byte[Base64.ComputeDecodedLength(source)];
Assert.Equal(TransformationStatus.Done,
Base64.Decoder.Transform(source, decodedBytes, out int consumed, out int decodedByteCount));
Assert.Equal(decodedBytes.Length, decodedByteCount);
string expectedStr = Text.Encoding.ASCII.GetString(source.ToArray());
byte[] expectedText = Convert.FromBase64String(expectedStr);
Assert.True(expectedText.AsSpan().SequenceEqual(decodedBytes));
}
}
