public AsciiString ToUpperCase()
{
var thisLen = this.length;
if (0u >= (uint)thisLen)
{
return(this);
}
var thisSpan = this.AsciiSpan;
var index = SpanHelpers.FindIndex(ref MemoryMarshal.GetReference(thisSpan), x => IsLowerCase(x), thisLen);
uint uIndex = (uint)index;
if (uIndex > SharedConstants.TooBigOrNegative)
{
return(this);
}
byte[] buffer = new byte[thisLen];
var span = new Span <byte>(buffer);
if (uIndex > 0u)
{
thisSpan.Slice(0, index).CopyTo(span.Slice(0, index));
}
for (var idx = index; idx < thisLen; idx++)
{
byte oldValue = thisSpan[idx];
span[idx] = ToUpperCase(thisSpan[idx]);
}
return(new AsciiString(buffer, false));
}
public void ZeroLengthIndexOf_Byte()
{
Span <byte> sp = new Span <byte>(EmptyArray <byte> .Instance);
//int idx = sp.IndexOf<byte>(0);
int idx = SpanHelpers.FindIndex(ref MemoryMarshal.GetReference(sp), x => x == 0, sp.Length);
Assert.Equal(-1, idx);
}
public void MakeSureNoChecksGoOutOfRange_Byte()
{
for (int length = 0; length <= byte.MaxValue; length++)
{
byte[] a = new byte[length + 2];
a[0] = 99;
a[length + 1] = 99;
Span <byte> span = new Span <byte>(a, 1, length);
//int index = span.IndexOf<byte>(99);
int index = SpanHelpers.FindIndex(ref MemoryMarshal.GetReference(span), x => x == 99, span.Length);
Assert.Equal(-1, index);
}
}
public void TestAllignmentNoMatch_Byte()
{
byte[] array = new byte[4 * Vector <byte> .Count];
for (var i = 0; i < Vector <byte> .Count; i++)
{
var span = new Span <byte>(array, i, 3 * Vector <byte> .Count);
//int idx = span.IndexOf((byte)'1');
int idx = SpanHelpers.FindIndex(ref MemoryMarshal.GetReference(span), x => x == (byte)'1', span.Length);
Assert.Equal(-1, idx);
span = new Span <byte>(array, i, 3 * Vector <byte> .Count - 3);
//idx = span.IndexOf((byte)'1');
idx = SpanHelpers.FindIndex(ref MemoryMarshal.GetReference(span), x => x == (byte)'1', span.Length);
Assert.Equal(-1, idx);
}
}
public void DefaultFilledIndexOf_Byte()
{
for (int length = 0; length <= byte.MaxValue; length++)
{
byte[] a = new byte[length];
Span <byte> span = new Span <byte>(a);
for (int i = 0; i < length; i++)
{
byte target0 = default;
//int idx = span.IndexOf(target0);
int idx = SpanHelpers.FindIndex(ref MemoryMarshal.GetReference(span), x => x == target0, span.Length);
Assert.Equal(0, idx);
}
}
}
public static void IndexOfAnyStrings_Byte(string raw, string search, char expectResult, int expectIndex)
{
byte[] buffers = Encoding.UTF8.GetBytes(raw);
var span = new Span <byte>(buffers);
char[] searchFor = search.ToCharArray();
byte[] searchForBytes = Encoding.UTF8.GetBytes(searchFor);
var index = -1;
if (searchFor.Length == 1)
{
//index = span.IndexOf((byte)searchFor[0]);
index = SpanHelpers.FindIndex(ref MemoryMarshal.GetReference(span),
x => x == (byte)searchFor[0],
span.Length);
}
else if (searchFor.Length == 2)
{
//index = span.IndexOfAny((byte)searchFor[0], (byte)searchFor[1]);
index = SpanHelpers.FindIndex(ref MemoryMarshal.GetReference(span),
x => x == (byte)searchFor[0] || x == (byte)searchFor[1],
span.Length);
}
else if (searchFor.Length == 3)
{
//index = span.IndexOfAny((byte)searchFor[0], (byte)searchFor[1], (byte)searchFor[2]);
index = SpanHelpers.FindIndex(ref MemoryMarshal.GetReference(span),
x => x == (byte)searchFor[0] || x == (byte)searchFor[1] || x == (byte)searchFor[2],
span.Length);
}
else
{
//index = span.IndexOfAny(new ReadOnlySpan<byte>(searchForBytes));
index = SpanHelpers.FindIndex(ref MemoryMarshal.GetReference(span),
x => searchForBytes.Contains(x),
span.Length);
}
var found = span[index];
Assert.Equal((byte)expectResult, found);
Assert.Equal(expectIndex, index);
}
public void TestNoMatch_Byte()
{
var rnd = new Random(42);
for (int length = 0; length <= byte.MaxValue; length++)
{
byte[] a = new byte[length];
byte target = (byte)rnd.Next(0, 256);
for (int i = 0; i < length; i++)
{
byte val = (byte)(i + 1);
a[i] = val == target ? (byte)(target + 1) : val;
}
Span <byte> span = new Span <byte>(a);
//int idx = span.IndexOf(target);
int idx = SpanHelpers.FindIndex(ref MemoryMarshal.GetReference(span), x => x == target, span.Length);
Assert.Equal(-1, idx);
}
}
public void TestMatch_Byte()
{
for (int length = 0; length <= byte.MaxValue; length++)
{
byte[] a = new byte[length];
for (int i = 0; i < length; i++)
{
a[i] = (byte)(i + 1);
}
Span <byte> span = new Span <byte>(a);
for (int targetIndex = 0; targetIndex < length; targetIndex++)
{
byte target = a[targetIndex];
//int idx = span.IndexOf(target);
int idx = SpanHelpers.FindIndex(ref MemoryMarshal.GetReference(span), x => x == target, span.Length);
Assert.Equal(targetIndex, idx);
}
}
}
public void TestMultipleMatch_Byte()
{
for (int length = 2; length <= byte.MaxValue; length++)
{
byte[] a = new byte[length];
for (int i = 0; i < length; i++)
{
byte val = (byte)(i + 1);
a[i] = val == 200 ? (byte)201 : val;
}
a[length - 1] = 200;
a[length - 2] = 200;
Span <byte> span = new Span <byte>(a);
//int idx = span.IndexOf<byte>(200);
int idx = SpanHelpers.FindIndex(ref MemoryMarshal.GetReference(span), x => x == 200, span.Length);
Assert.Equal(length - 2, idx);
}
}
