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 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 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());
}
