Welcome to mirror list, hosted at ThFree Co, Russian Federation.

github.com/mono/corefx.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/src/System.Memory/tests
diff options
context:
space:
mode:
Diffstat (limited to 'src/System.Memory/tests')
-rw-r--r--src/System.Memory/tests/Memory/Pin.cs133
-rw-r--r--src/System.Memory/tests/Memory/Retain.cs48
-rw-r--r--src/System.Memory/tests/Memory/Strings.cs9
-rw-r--r--src/System.Memory/tests/MemoryMarshal/AsMemory.cs23
-rw-r--r--src/System.Memory/tests/ReadOnlyMemory/Pin.cs133
-rw-r--r--src/System.Memory/tests/ReadOnlyMemory/Retain.cs30
-rw-r--r--src/System.Memory/tests/ReadOnlyMemory/Strings.cs11
-rw-r--r--src/System.Memory/tests/System.Memory.Tests.csproj2
8 files changed, 325 insertions, 64 deletions
diff --git a/src/System.Memory/tests/Memory/Pin.cs b/src/System.Memory/tests/Memory/Pin.cs
new file mode 100644
index 0000000000..2d0d8ff523
--- /dev/null
+++ b/src/System.Memory/tests/Memory/Pin.cs
@@ -0,0 +1,133 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Buffers;
+using Xunit;
+
+namespace System.MemoryTests
+{
+ public static partial class MemoryTests
+ {
+ [Fact]
+ public static void MemoryPin()
+ {
+ int[] array = { 1, 2, 3, 4, 5 };
+ Memory<int> memory = array;
+ MemoryHandle handle = memory.Pin();
+ Assert.True(handle.HasPointer);
+ unsafe
+ {
+ int* pointer = (int*)handle.Pointer;
+
+ GC.Collect();
+
+ for (int i = 0; i < memory.Length; i++)
+ {
+ Assert.Equal(array[i], pointer[i]);
+ }
+ }
+ handle.Dispose();
+ }
+
+ [Fact]
+ public static void MemoryFromEmptyArrayPin()
+ {
+ Memory<int> memory = new int[0];
+ MemoryHandle handle = memory.Pin();
+ Assert.True(handle.HasPointer);
+ handle.Dispose();
+ }
+
+ [Fact]
+ public static void DefaultMemoryPin()
+ {
+ Memory<int> memory = default;
+ MemoryHandle handle = memory.Pin();
+ Assert.False(handle.HasPointer);
+ unsafe
+ {
+ Assert.True(handle.Pointer == null);
+ }
+ handle.Dispose();
+ }
+
+ [Fact]
+ public static void MemoryPinAndSlice()
+ {
+ int[] array = { 1, 2, 3, 4, 5 };
+ Memory<int> memory = array;
+ memory = memory.Slice(1);
+ MemoryHandle handle = memory.Pin();
+ Span<int> span = memory.Span;
+ Assert.True(handle.HasPointer);
+ unsafe
+ {
+ int* pointer = (int*)handle.Pointer;
+
+ GC.Collect();
+
+ for (int i = 0; i < memory.Length; i++)
+ {
+ Assert.Equal(array[i + 1], pointer[i]);
+ }
+
+ for (int i = 0; i < memory.Length; i++)
+ {
+ Assert.Equal(array[i + 1], span[i]);
+ }
+ }
+ handle.Dispose();
+ }
+
+ [Fact]
+ public static void OwnedMemoryPin()
+ {
+ int[] array = { 1, 2, 3, 4, 5 };
+ OwnedMemory<int> owner = new CustomMemoryForTest<int>(array);
+ Memory<int> memory = owner.Memory;
+ MemoryHandle handle = memory.Pin();
+ Assert.True(handle.HasPointer);
+ unsafe
+ {
+ int* pointer = (int*)handle.Pointer;
+
+ GC.Collect();
+
+ for (int i = 0; i < memory.Length; i++)
+ {
+ Assert.Equal(array[i], pointer[i]);
+ }
+ }
+ handle.Dispose();
+ }
+
+ [Fact]
+ public static void OwnedMemoryPinAndSlice()
+ {
+ int[] array = { 1, 2, 3, 4, 5 };
+ OwnedMemory<int> owner = new CustomMemoryForTest<int>(array);
+ Memory<int> memory = owner.Memory.Slice(1);
+ MemoryHandle handle = memory.Pin();
+ Span<int> span = memory.Span;
+ Assert.True(handle.HasPointer);
+ unsafe
+ {
+ int* pointer = (int*)handle.Pointer;
+
+ GC.Collect();
+
+ for (int i = 0; i < memory.Length; i++)
+ {
+ Assert.Equal(array[i + 1], pointer[i]);
+ }
+
+ for (int i = 0; i < memory.Length; i++)
+ {
+ Assert.Equal(array[i + 1], span[i]);
+ }
+ }
+ handle.Dispose();
+ }
+ }
+}
diff --git a/src/System.Memory/tests/Memory/Retain.cs b/src/System.Memory/tests/Memory/Retain.cs
index 3a33817dff..1ef319103c 100644
--- a/src/System.Memory/tests/Memory/Retain.cs
+++ b/src/System.Memory/tests/Memory/Retain.cs
@@ -46,6 +46,30 @@ namespace System.MemoryTests
}
[Fact]
+ public static void MemoryFromEmptyArrayRetainWithPinning()
+ {
+ Memory<int> memory = new int[0];
+ MemoryHandle handle = memory.Retain(pin: true);
+ Assert.True(handle.HasPointer);
+ handle.Dispose();
+ }
+
+ [Theory]
+ [InlineData(true)]
+ [InlineData(false)]
+ public static void DefaultMemoryRetain(bool pin)
+ {
+ Memory<int> memory = default;
+ MemoryHandle handle = memory.Retain(pin: pin);
+ Assert.False(handle.HasPointer);
+ unsafe
+ {
+ Assert.True(handle.Pointer == null);
+ }
+ handle.Dispose();
+ }
+
+ [Fact]
public static void MemoryRetainWithPinningAndSlice()
{
int[] array = { 1, 2, 3, 4, 5 };
@@ -111,15 +135,6 @@ namespace System.MemoryTests
}
[Fact]
- public static void MemoryFromEmptyArrayRetainWithPinning()
- {
- Memory<int> memory = new int[0];
- MemoryHandle handle = memory.Retain(pin: true);
- Assert.True(handle.HasPointer);
- handle.Dispose();
- }
-
- [Fact]
public static void OwnedMemoryRetainWithPinningAndSlice()
{
int[] array = { 1, 2, 3, 4, 5 };
@@ -146,20 +161,5 @@ namespace System.MemoryTests
}
handle.Dispose();
}
-
- [Theory]
- [InlineData(true)]
- [InlineData(false)]
- public static void DefaultMemoryRetain(bool pin)
- {
- Memory<int> memory = default;
- MemoryHandle handle = memory.Retain(pin: pin);
- Assert.False(handle.HasPointer);
- unsafe
- {
- Assert.True(handle.Pointer == null);
- }
- handle.Dispose();
- }
}
}
diff --git a/src/System.Memory/tests/Memory/Strings.cs b/src/System.Memory/tests/Memory/Strings.cs
index 6e4e0bfe05..b711179cd1 100644
--- a/src/System.Memory/tests/Memory/Strings.cs
+++ b/src/System.Memory/tests/Memory/Strings.cs
@@ -57,18 +57,13 @@ namespace System.MemoryTests
}
[Fact]
- public static unsafe void Memory_Retain_ExpectedPointerValue()
+ public static unsafe void Memory_Pin_ExpectedPointerValue()
{
string input = "0123456789";
ReadOnlyMemory<char> readonlyMemory = input.AsMemory();
Memory<char> m = MemoryMarshal.AsMemory(readonlyMemory);
- using (MemoryHandle h = m.Retain(pin: false))
- {
- Assert.Equal(IntPtr.Zero, (IntPtr)h.Pointer);
- }
-
- using (MemoryHandle h = m.Retain(pin: true))
+ using (MemoryHandle h = m.Pin())
{
GC.Collect();
fixed (char* ptr = input)
diff --git a/src/System.Memory/tests/MemoryMarshal/AsMemory.cs b/src/System.Memory/tests/MemoryMarshal/AsMemory.cs
index 43b3ab1c3a..40990d08cb 100644
--- a/src/System.Memory/tests/MemoryMarshal/AsMemory.cs
+++ b/src/System.Memory/tests/MemoryMarshal/AsMemory.cs
@@ -39,17 +39,17 @@ namespace System.MemoryTests
[Theory]
[MemberData(nameof(ReadOnlyMemoryInt32Instances))]
- public static void AsMemory_Roundtrips(ReadOnlyMemory<int> readOnlyMemory) => AsMemory_Roundtrips_Core(readOnlyMemory);
+ public static void AsMemory_Roundtrips(ReadOnlyMemory<int> readOnlyMemory) => AsMemory_Roundtrips_Core(readOnlyMemory, true);
[Theory]
[MemberData(nameof(ReadOnlyMemoryObjectInstances))]
- public static void AsMemory_Roundtrips(ReadOnlyMemory<object> readOnlyMemory) => AsMemory_Roundtrips_Core(readOnlyMemory);
+ public static void AsMemory_Roundtrips(ReadOnlyMemory<object> readOnlyMemory) => AsMemory_Roundtrips_Core(readOnlyMemory, false);
[Theory]
[MemberData(nameof(ReadOnlyMemoryCharInstances))]
public static void AsMemory_Roundtrips(ReadOnlyMemory<char> readOnlyMemory)
{
- AsMemory_Roundtrips_Core(readOnlyMemory);
+ AsMemory_Roundtrips_Core(readOnlyMemory, true);
Memory<char> memory = MemoryMarshal.AsMemory(readOnlyMemory);
ReadOnlyMemory<char> readOnlyClone = memory;
@@ -66,7 +66,7 @@ namespace System.MemoryTests
}
}
- private static unsafe void AsMemory_Roundtrips_Core<T>(ReadOnlyMemory<T> readOnlyMemory)
+ private static unsafe void AsMemory_Roundtrips_Core<T>(ReadOnlyMemory<T> readOnlyMemory, bool canBePinned)
{
Memory<T> memory = MemoryMarshal.AsMemory(readOnlyMemory);
ReadOnlyMemory<T> readOnlyClone = memory;
@@ -87,13 +87,16 @@ namespace System.MemoryTests
Assert.Equal(array1.Offset, array2.Offset);
Assert.Equal(array1.Count, array2.Count);
- // Retain
- using (MemoryHandle readOnlyMemoryHandle = readOnlyMemory.Retain())
- using (MemoryHandle readOnlyCloneHandle = readOnlyMemory.Retain())
- using (MemoryHandle memoryHandle = readOnlyMemory.Retain())
+ if (canBePinned)
{
- Assert.Equal((IntPtr)readOnlyMemoryHandle.Pointer, (IntPtr)readOnlyCloneHandle.Pointer);
- Assert.Equal((IntPtr)readOnlyMemoryHandle.Pointer, (IntPtr)memoryHandle.Pointer);
+ // Pin
+ using (MemoryHandle readOnlyMemoryHandle = readOnlyMemory.Pin())
+ using (MemoryHandle readOnlyCloneHandle = readOnlyMemory.Pin())
+ using (MemoryHandle memoryHandle = readOnlyMemory.Pin())
+ {
+ Assert.Equal((IntPtr)readOnlyMemoryHandle.Pointer, (IntPtr)readOnlyCloneHandle.Pointer);
+ Assert.Equal((IntPtr)readOnlyMemoryHandle.Pointer, (IntPtr)memoryHandle.Pointer);
+ }
}
}
}
diff --git a/src/System.Memory/tests/ReadOnlyMemory/Pin.cs b/src/System.Memory/tests/ReadOnlyMemory/Pin.cs
new file mode 100644
index 0000000000..803612035c
--- /dev/null
+++ b/src/System.Memory/tests/ReadOnlyMemory/Pin.cs
@@ -0,0 +1,133 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Buffers;
+using Xunit;
+
+namespace System.MemoryTests
+{
+ public static partial class ReadOnlyMemoryTests
+ {
+ [Fact]
+ public static void MemoryPin()
+ {
+ int[] array = { 1, 2, 3, 4, 5 };
+ ReadOnlyMemory<int> memory = array;
+ MemoryHandle handle = memory.Pin();
+ Assert.True(handle.HasPointer);
+ unsafe
+ {
+ int* pointer = (int*)handle.Pointer;
+
+ GC.Collect();
+
+ for (int i = 0; i < memory.Length; i++)
+ {
+ Assert.Equal(array[i], pointer[i]);
+ }
+ }
+ handle.Dispose();
+ }
+
+ [Fact]
+ public static void MemoryFromEmptyArrayPin()
+ {
+ ReadOnlyMemory<int> memory = new int[0];
+ MemoryHandle handle = memory.Pin();
+ Assert.True(handle.HasPointer);
+ handle.Dispose();
+ }
+
+ [Fact]
+ public static void DefaultMemoryPin()
+ {
+ ReadOnlyMemory<int> memory = default;
+ MemoryHandle handle = memory.Pin();
+ Assert.False(handle.HasPointer);
+ unsafe
+ {
+ Assert.True(handle.Pointer == null);
+ }
+ handle.Dispose();
+ }
+
+ [Fact]
+ public static void MemoryPinAndSlice()
+ {
+ int[] array = { 1, 2, 3, 4, 5 };
+ ReadOnlyMemory<int> memory = array;
+ memory = memory.Slice(1);
+ MemoryHandle handle = memory.Pin();
+ ReadOnlySpan<int> span = memory.Span;
+ Assert.True(handle.HasPointer);
+ unsafe
+ {
+ int* pointer = (int*)handle.Pointer;
+
+ GC.Collect();
+
+ for (int i = 0; i < memory.Length; i++)
+ {
+ Assert.Equal(array[i + 1], pointer[i]);
+ }
+
+ for (int i = 0; i < memory.Length; i++)
+ {
+ Assert.Equal(array[i + 1], span[i]);
+ }
+ }
+ handle.Dispose();
+ }
+
+ [Fact]
+ public static void OwnedMemoryPin()
+ {
+ int[] array = { 1, 2, 3, 4, 5 };
+ OwnedMemory<int> owner = new CustomMemoryForTest<int>(array);
+ ReadOnlyMemory<int> memory = owner.Memory;
+ MemoryHandle handle = memory.Pin();
+ Assert.True(handle.HasPointer);
+ unsafe
+ {
+ int* pointer = (int*)handle.Pointer;
+
+ GC.Collect();
+
+ for (int i = 0; i < memory.Length; i++)
+ {
+ Assert.Equal(array[i], pointer[i]);
+ }
+ }
+ handle.Dispose();
+ }
+
+ [Fact]
+ public static void OwnedMemoryPinAndSlice()
+ {
+ int[] array = { 1, 2, 3, 4, 5 };
+ OwnedMemory<int> owner = new CustomMemoryForTest<int>(array);
+ ReadOnlyMemory<int> memory = owner.Memory.Slice(1);
+ MemoryHandle handle = memory.Pin();
+ ReadOnlySpan<int> span = memory.Span;
+ Assert.True(handle.HasPointer);
+ unsafe
+ {
+ int* pointer = (int*)handle.Pointer;
+
+ GC.Collect();
+
+ for (int i = 0; i < memory.Length; i++)
+ {
+ Assert.Equal(array[i + 1], pointer[i]);
+ }
+
+ for (int i = 0; i < memory.Length; i++)
+ {
+ Assert.Equal(array[i + 1], span[i]);
+ }
+ }
+ handle.Dispose();
+ }
+ }
+}
diff --git a/src/System.Memory/tests/ReadOnlyMemory/Retain.cs b/src/System.Memory/tests/ReadOnlyMemory/Retain.cs
index 6f31b00cd0..d438c78d77 100644
--- a/src/System.Memory/tests/ReadOnlyMemory/Retain.cs
+++ b/src/System.Memory/tests/ReadOnlyMemory/Retain.cs
@@ -54,6 +54,21 @@ namespace System.MemoryTests
handle.Dispose();
}
+ [Theory]
+ [InlineData(true)]
+ [InlineData(false)]
+ public static void DefaultMemoryRetain(bool pin)
+ {
+ ReadOnlyMemory<int> memory = default;
+ MemoryHandle handle = memory.Retain(pin: pin);
+ Assert.False(handle.HasPointer);
+ unsafe
+ {
+ Assert.True(handle.Pointer == null);
+ }
+ handle.Dispose();
+ }
+
[Fact]
public static void MemoryRetainWithPinningAndSlice()
{
@@ -146,20 +161,5 @@ namespace System.MemoryTests
}
handle.Dispose();
}
-
- [Theory]
- [InlineData(true)]
- [InlineData(false)]
- public static void DefaultMemoryRetain(bool pin)
- {
- ReadOnlyMemory<int> memory = default;
- MemoryHandle handle = memory.Retain(pin: pin);
- Assert.False(handle.HasPointer);
- unsafe
- {
- Assert.True(handle.Pointer == null);
- }
- handle.Dispose();
- }
}
}
diff --git a/src/System.Memory/tests/ReadOnlyMemory/Strings.cs b/src/System.Memory/tests/ReadOnlyMemory/Strings.cs
index ba7e86b8f2..6a775ad87a 100644
--- a/src/System.Memory/tests/ReadOnlyMemory/Strings.cs
+++ b/src/System.Memory/tests/ReadOnlyMemory/Strings.cs
@@ -94,17 +94,12 @@ namespace System.MemoryTests
}
[Fact]
- public static unsafe void AsReadOnlyMemory_Retain_ExpectedPointerValue()
+ public static unsafe void AsReadOnlyMemory_Pin_ExpectedPointerValue()
{
string input = "0123456789";
ReadOnlyMemory<char> m = input.AsMemory();
- using (MemoryHandle h = m.Retain(pin: false))
- {
- Assert.Equal(IntPtr.Zero, (IntPtr)h.Pointer);
- }
-
- using (MemoryHandle h = m.Retain(pin: true))
+ using (MemoryHandle h = m.Pin())
{
GC.Collect();
fixed (char* ptr = input)
@@ -137,7 +132,7 @@ namespace System.MemoryTests
Assert.Equal(length, m.Length);
- using (MemoryHandle h = m.Retain(pin: true))
+ using (MemoryHandle h = m.Pin())
{
fixed (char* pText = text)
{
diff --git a/src/System.Memory/tests/System.Memory.Tests.csproj b/src/System.Memory/tests/System.Memory.Tests.csproj
index 47a328f7f8..27d689a92a 100644
--- a/src/System.Memory/tests/System.Memory.Tests.csproj
+++ b/src/System.Memory/tests/System.Memory.Tests.csproj
@@ -163,6 +163,7 @@
<Compile Include="Memory\GetHashCode.cs" />
<Compile Include="Memory\ImplicitConversion.cs" />
<Compile Include="Memory\OwnedMemory.cs" />
+ <Compile Include="Memory\Pin.cs" />
<Compile Include="Memory\Retain.cs" />
<Compile Include="Memory\Slice.cs" />
<Compile Include="Memory\Span.cs" />
@@ -193,6 +194,7 @@
<Compile Include="ReadOnlyMemory\Equality.cs" />
<Compile Include="ReadOnlyMemory\GetHashCode.cs" />
<Compile Include="ReadOnlyMemory\ImplicitConversion.cs" />
+ <Compile Include="ReadOnlyMemory\Pin.cs" />
<Compile Include="ReadOnlyMemory\Retain.cs" />
<Compile Include="ReadOnlyMemory\Slice.cs" />
<Compile Include="ReadOnlyMemory\Span.cs" />
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-22 18:39:39 +0300