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