public static void ToStringMemoryOverFullStringReturnsOriginal()
{
string original = MemoryTestHelpers.BuildString(10, 42);
ReadOnlyMemory <char> readOnlyMemory = original.AsMemory();
Memory <char> memory = MemoryMarshal.AsMemory(readOnlyMemory);
string returnedString = memory.ToString();
string returnedStringUsingSlice = memory.Slice(0, original.Length).ToString();
string subString1 = memory.Slice(1).ToString();
string subString2 = memory.Slice(0, 2).ToString();
string subString3 = memory.Slice(1, 2).ToString();
Assert.Equal(original, returnedString);
Assert.Equal(original, returnedStringUsingSlice);
Assert.Equal(original.Substring(1), subString1);
Assert.Equal(original.Substring(0, 2), subString2);
Assert.Equal(original.Substring(1, 2), subString3);
Assert.Same(original, returnedString);
Assert.Same(original, returnedStringUsingSlice);
Assert.NotSame(original, subString1);
Assert.NotSame(original, subString2);
Assert.NotSame(original, subString3);
Assert.NotSame(subString1, subString2);
Assert.NotSame(subString1, subString3);
Assert.NotSame(subString2, subString3);
}
public static unsafe void CastSpanOverflow()
{
Span <MemoryTestHelpers.TestStructExplicit> span = new Span <MemoryTestHelpers.TestStructExplicit>(null, int.MaxValue);
MemoryTestHelpers.AssertThrows <OverflowException, MemoryTestHelpers.TestStructExplicit>(span, (_span) => MemoryMarshal.Cast <MemoryTestHelpers.TestStructExplicit, byte>(_span).DontBox());
MemoryTestHelpers.AssertThrows <OverflowException, MemoryTestHelpers.TestStructExplicit>(span, (_span) => MemoryMarshal.Cast <MemoryTestHelpers.TestStructExplicit, ulong>(_span).DontBox());
}
public void ReadOnlySpanReadFail()
{
ReadOnlySpan <byte> span = new byte[] { 1 };
Assert.Equal <byte>(1, MemoryMarshal.Read <byte>(span));
Assert.True(MemoryMarshal.TryRead(span, out byte byteValue));
Assert.Equal(1, byteValue);
MemoryTestHelpers.AssertThrows <ArgumentOutOfRangeException, byte>(span, (_span) => MemoryMarshal.Read <short>(_span));
Assert.False(MemoryMarshal.TryRead(span, out short shortValue));
MemoryTestHelpers.AssertThrows <ArgumentOutOfRangeException, byte>(span, (_span) => MemoryMarshal.Read <int>(_span));
Assert.False(MemoryMarshal.TryRead(span, out int intValue));
MemoryTestHelpers.AssertThrows <ArgumentOutOfRangeException, byte>(span, (_span) => MemoryMarshal.Read <long>(_span));
Assert.False(MemoryMarshal.TryRead(span, out long longValue));
MemoryTestHelpers.AssertThrows <ArgumentOutOfRangeException, byte>(span, (_span) => MemoryMarshal.Read <ushort>(_span));
Assert.False(MemoryMarshal.TryRead(span, out ushort ushortValue));
MemoryTestHelpers.AssertThrows <ArgumentOutOfRangeException, byte>(span, (_span) => MemoryMarshal.Read <uint>(_span));
Assert.False(MemoryMarshal.TryRead(span, out uint uintValue));
MemoryTestHelpers.AssertThrows <ArgumentOutOfRangeException, byte>(span, (_span) => MemoryMarshal.Read <ulong>(_span));
Assert.False(MemoryMarshal.TryRead(span, out ulong ulongValue));
ReadOnlySpan <byte> largeSpan = new byte[100];
MemoryTestHelpers.AssertThrows <ArgumentException, byte>(largeSpan, (_span) => MemoryMarshal.Read <MemoryTestHelpers.TestValueTypeWithReference>(_span));
MemoryTestHelpers.AssertThrows <ArgumentException, byte>(largeSpan, (_span) => MemoryMarshal.TryRead(_span, out MemoryTestHelpers.TestValueTypeWithReference stringValue));
}
public static void ToStringSpanOverSubstringDoesNotReturnOriginal()
{
string original = MemoryTestHelpers.BuildString(10, 42);
ReadOnlySpan <char> span = original.AsSpan();
string returnedString = span.ToString();
string returnedStringUsingSlice = span.Slice(0, original.Length).ToString();
string subString1 = span.Slice(1).ToString();
string subString2 = span.Slice(0, 2).ToString();
string subString3 = span.Slice(1, 2).ToString();
Assert.Equal(original, returnedString);
Assert.Equal(original, returnedStringUsingSlice);
Assert.Equal(original.Substring(1), subString1);
Assert.Equal(original.Substring(0, 2), subString2);
Assert.Equal(original.Substring(1, 2), subString3);
Assert.NotSame(original, subString1);
Assert.NotSame(original, subString2);
Assert.NotSame(original, subString3);
Assert.NotSame(subString1, subString2);
Assert.NotSame(subString1, subString3);
Assert.NotSame(subString2, subString3);
}
public static void EqualsUnknownComparisonType_StringComparison()
{
char[] a = { '4', '5', '6' };
var span = new ReadOnlySpan <char>(a);
MemoryTestHelpers.AssertThrows <ArgumentException, char>(span, (_span) => _span.Equals(_span, StringComparison.CurrentCulture - 1));
MemoryTestHelpers.AssertThrows <ArgumentException, char>(span, (_span) => _span.Equals(_span, StringComparison.OrdinalIgnoreCase + 1));
MemoryTestHelpers.AssertThrows <ArgumentException, char>(span, (_span) => _span.Equals(_span, (StringComparison)6));
}
public void SpanWriteFail()
{
byte byteValue = 1;
sbyte sbyteValue = 1;
short shortValue = 1;
ushort ushortValue = 1;
int intValue = 1;
uint uintValue = 1;
long longValue = 1;
ulong ulongValue = 1;
Span <byte> span = new byte[1];
MemoryMarshal.Write <byte>(span, ref byteValue);
byte read = MemoryMarshal.Read <byte>(span);
Assert.Equal <byte>(byteValue, read);
span.Clear();
Assert.True(MemoryMarshal.TryWrite <byte>(span, ref byteValue));
read = MemoryMarshal.Read <byte>(span);
Assert.Equal <byte>(byteValue, read);
MemoryMarshal.Write <sbyte>(span, ref sbyteValue);
sbyte readSbyte = MemoryMarshal.Read <sbyte>(span);
Assert.Equal <sbyte>(sbyteValue, readSbyte);
span.Clear();
Assert.True(MemoryMarshal.TryWrite <sbyte>(span, ref sbyteValue));
readSbyte = MemoryMarshal.Read <sbyte>(span);
Assert.Equal <sbyte>(sbyteValue, readSbyte);
MemoryTestHelpers.AssertThrows <ArgumentOutOfRangeException, byte>(span, (_span) => MemoryMarshal.Write <short>(_span, ref shortValue));
Assert.False(MemoryMarshal.TryWrite <short>(span, ref shortValue));
MemoryTestHelpers.AssertThrows <ArgumentOutOfRangeException, byte>(span, (_span) => MemoryMarshal.Write <int>(_span, ref intValue));
Assert.False(MemoryMarshal.TryWrite <int>(span, ref intValue));
MemoryTestHelpers.AssertThrows <ArgumentOutOfRangeException, byte>(span, (_span) => MemoryMarshal.Write <long>(_span, ref longValue));
Assert.False(MemoryMarshal.TryWrite <long>(span, ref longValue));
MemoryTestHelpers.AssertThrows <ArgumentOutOfRangeException, byte>(span, (_span) => MemoryMarshal.Write <ushort>(_span, ref ushortValue));
Assert.False(MemoryMarshal.TryWrite <ushort>(span, ref ushortValue));
MemoryTestHelpers.AssertThrows <ArgumentOutOfRangeException, byte>(span, (_span) => MemoryMarshal.Write <uint>(_span, ref uintValue));
Assert.False(MemoryMarshal.TryWrite <uint>(span, ref uintValue));
MemoryTestHelpers.AssertThrows <ArgumentOutOfRangeException, byte>(span, (_span) => MemoryMarshal.Write <ulong>(_span, ref ulongValue));
Assert.False(MemoryMarshal.TryWrite <ulong>(span, ref ulongValue));
var structValue = new MemoryTestHelpers.TestValueTypeWithReference {
I = 1, S = "1"
};
MemoryTestHelpers.AssertThrows <ArgumentException, byte>(span, (_span) => MemoryMarshal.Write <MemoryTestHelpers.TestValueTypeWithReference>(_span, ref structValue));
MemoryTestHelpers.AssertThrows <ArgumentException, byte>(span, (_span) => MemoryMarshal.TryWrite <MemoryTestHelpers.TestValueTypeWithReference>(_span, ref structValue));
}
public static void CopyToShorter()
{
int[] src = { 1, 2, 3 };
int[] dst = { 99, 100 };
ReadOnlySpan <int> srcSpan = new ReadOnlySpan <int>(src);
MemoryTestHelpers.AssertThrows <ArgumentException, int>(srcSpan, (_srcSpan) => _srcSpan.CopyTo(dst));
int[] expected = { 99, 100 };
Assert.Equal <int>(expected, dst); // CopyTo() checks for sufficient space before doing any copying.
}
public static void CopyToShorterArray()
{
int[] src = { 1, 2, 3 };
int[] dst = new int[2] {
99, 100
};
MemoryTestHelpers.AssertThrows <ArgumentException, int>(src, (_src) => _src.CopyTo(dst));
int[] expected = { 99, 100 };
Assert.Equal <int>(expected, dst); // CopyTo() checks for sufficient space before doing any copying.
}
public static void Span_AsBytesContainsReferences()
{
Span <MemoryTestHelpers.StructWithReferences> span = new Span <MemoryTestHelpers.StructWithReferences>(Array.Empty <MemoryTestHelpers.StructWithReferences>());
MemoryTestHelpers.AssertThrows <ArgumentException, MemoryTestHelpers.StructWithReferences>(span, (_span) => MemoryMarshal.AsBytes(_span).DontBox());
}
public void SpanWrite()
{
Assert.True(BitConverter.IsLittleEndian);
Span <byte> span = new byte[8];
byte byteValue = 0x11;
MemoryMarshal.Write <byte>(span, ref byteValue);
MemoryTestHelpers.Validate <byte>(span, byteValue);
Assert.True(MemoryMarshal.TryWrite <byte>(span, ref byteValue));
MemoryTestHelpers.Validate <byte>(span, byteValue);
sbyte sbyteValue = 0x11;
MemoryMarshal.Write <sbyte>(span, ref sbyteValue);
MemoryTestHelpers.Validate <sbyte>(span, sbyteValue);
Assert.True(MemoryMarshal.TryWrite <sbyte>(span, ref sbyteValue));
MemoryTestHelpers.Validate <sbyte>(span, sbyteValue);
ushort ushortValue = 0x1122;
MemoryMarshal.Write <ushort>(span, ref ushortValue);
MemoryTestHelpers.Validate <ushort>(span, ushortValue);
Assert.True(MemoryMarshal.TryWrite <ushort>(span, ref ushortValue));
MemoryTestHelpers.Validate <ushort>(span, ushortValue);
uint uintValue = 0x11223344;
MemoryMarshal.Write <uint>(span, ref uintValue);
MemoryTestHelpers.Validate <uint>(span, uintValue);
Assert.True(MemoryMarshal.TryWrite <uint>(span, ref uintValue));
MemoryTestHelpers.Validate <uint>(span, uintValue);
ulong ulongValue = 0x1122334455667788;
MemoryMarshal.Write <ulong>(span, ref ulongValue);
MemoryTestHelpers.Validate <ulong>(span, ulongValue);
Assert.True(MemoryMarshal.TryWrite <ulong>(span, ref ulongValue));
MemoryTestHelpers.Validate <ulong>(span, ulongValue);
short shortValue = 0x1122;
MemoryMarshal.Write <short>(span, ref shortValue);
MemoryTestHelpers.Validate <short>(span, shortValue);
Assert.True(MemoryMarshal.TryWrite <short>(span, ref shortValue));
MemoryTestHelpers.Validate <short>(span, shortValue);
int intValue = 0x11223344;
MemoryMarshal.Write <int>(span, ref intValue);
MemoryTestHelpers.Validate <int>(span, intValue);
Assert.True(MemoryMarshal.TryWrite <int>(span, ref intValue));
MemoryTestHelpers.Validate <int>(span, intValue);
long longValue = 0x1122334455667788;
MemoryMarshal.Write <long>(span, ref longValue);
MemoryTestHelpers.Validate <long>(span, longValue);
Assert.True(MemoryMarshal.TryWrite <long>(span, ref longValue));
MemoryTestHelpers.Validate <long>(span, longValue);
}
public static void MemoryExtensionsToUpperLowerOverlappingThrows(MemoryTestHelpers.AssertThrowsAction <char> action)
{
Span <char> buffer = new char[] { 'a', 'b', 'c', 'd' };
MemoryTestHelpers.AssertThrows <InvalidOperationException, char>(buffer, action);
}
public static void CastSpanFromTypeContainsReferences()
{
Span <MemoryTestHelpers.StructWithReferences> span = new Span <MemoryTestHelpers.StructWithReferences>(Array.Empty <MemoryTestHelpers.StructWithReferences>());
MemoryTestHelpers.AssertThrows <ArgumentException, MemoryTestHelpers.StructWithReferences>(span, (_span) => MemoryMarshal.Cast <MemoryTestHelpers.StructWithReferences, uint>(_span).DontBox());
}
public static void CastReadOnlySpanToTypeContainsReferences()
{
ReadOnlySpan <uint> span = new ReadOnlySpan <uint>(Array.Empty <uint>());
MemoryTestHelpers.AssertThrows <ArgumentException, uint>(span, (_span) => MemoryMarshal.Cast <uint, MemoryTestHelpers.StructWithReferences>(_span).DontBox());
}
