public void EncodingOutputTooSmall()
{
Span <byte> source = new byte[750];
Base64TestHelper.InitalizeBytes(source);
int outputSize = 320;
int requiredSize = Base64.BytesToUtf8Length(source.Length);
Span <byte> encodedBytes = new byte[outputSize];
Assert.Equal(OperationStatus.DestinationTooSmall,
Base64.BytesToUtf8(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.Equal(OperationStatus.Done,
Base64.BytesToUtf8(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);
}
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[Base64.BytesToUtf8Length(sourceBytes.Length)];
var bufferSlice = buffer.AsSpan();
Base64.BytesToUtf8(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);
Assert.Equal(OperationStatus.Done, Base64.Utf8ToBytesInPlace(bufferSlice, out int bytesConsumed, out int bytesWritten));
Assert.Equal(sourceBytes.Length, bytesWritten);
Assert.Equal(bufferSlice.Length, bytesConsumed);
for (int i = 0; i < bytesWritten; i++)
{
Assert.Equal(sourceBytes[i], bufferSlice[i]);
}
}
}
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[Base64.BytesToUtf8Length(sourceBytes.Length)];
Assert.Equal(OperationStatus.Done, Base64.BytesToUtf8(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[Base64.Utf8ToBytesLength(encodedBytes)];
Assert.Equal(OperationStatus.Done, Base64.Utf8ToBytes(encodedBytes, decodedBytes, out consumed, out int decodedByteCount));
Assert.Equal(sourceBytes.Length, decodedByteCount);
Assert.True(sourceBytes.SequenceEqual(decodedBytes));
}
}
}
private static void Base64Encode(int numberOfBytes)
{
Span <byte> source = new byte[numberOfBytes];
Base64TestHelper.InitalizeBytes(source);
Span <byte> destination = new byte[Base64.BytesToUtf8Length(numberOfBytes)];
foreach (var iteration in Benchmark.Iterations)
{
using (iteration.StartMeasurement()) {
for (int i = 0; i < Benchmark.InnerIterationCount; i++)
{
Base64.BytesToUtf8(source, destination, out int consumed, out int written);
}
}
}
}
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.BytesToUtf8Length(source.Length)];
Assert.Equal(OperationStatus.Done, Base64.BytesToUtf8(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.BytesToUtf8Length(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.BytesToUtf8(source, encodedSpan, out int consumed, out int written);
Base64.Utf8ToBytesInPlace(encodedSpan, out int bytesConsumed, out int bytesWritten);
}
}
}
}
