Add unit tests for ByRefLikeReference & subtypes

Author: stakx

src/Castle.Core.Tests/Castle.Core.Tests.csproj

@@ -4,6 +4,7 @@
 
 	<PropertyGroup>
 		<TargetFrameworks>net8.0;net9.0;net10.0;net462</TargetFrameworks>
+		<AllowUnsafeBlocks>True</AllowUnsafeBlocks>
 	</PropertyGroup>
 
 	<PropertyGroup>

src/Castle.Core.Tests/DynamicProxy.Tests/ByRefLikeSupport/ByRefLikeReferenceTestCase.cs

@@ -0,0 +1,151 @@
+// Copyright 2004-2026 Castle Project - http://www.castleproject.org/
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#if FEATURE_BYREFLIKE
+
+#nullable enable
+#pragma warning disable CS8500
+
+namespace Castle.DynamicProxy.Tests.ByRefLikeSupport
+{
+	using System;
+#if NET9_0_OR_GREATER
+	using System.Runtime.CompilerServices;
+#endif
+
+	using NUnit.Framework;
+
+	/// <summary>
+	///   Tests for the substitute types used by DynamicProxy to implement by-ref-like parameter and return type support.
+	/// </summary>
+	[TestFixture]
+	public class ByRefLikeReferenceTestCase
+	{
+		#region `ByRefLikeReference`
+
+		[Test]
+		public unsafe void Ctor_throws_if_non_by_ref_like_type()
+		{
+			Assert.Throws<ArgumentOutOfRangeException>(() =>
+			{
+				bool local = default;
+				_ = new ByRefLikeReference(typeof(bool), &local);
+			});
+		}
+
+		[Test]
+		public unsafe void Ctor_succeeds_if_by_ref_like_type()
+		{
+			ReadOnlySpan<char> local = default;
+			_ = new ByRefLikeReference(typeof(ReadOnlySpan<char>), &local);
+		}
+
+		[Test]
+		public unsafe void Invalidate_throws_if_address_mismatch()
+		{
+			ReadOnlySpan<char> local = default;
+			var reference = new ByRefLikeReference(typeof(ReadOnlySpan<char>), &local);
+			Assert.Throws<AccessViolationException>(() =>
+			{
+				ReadOnlySpan<char> otherLocal = default;
+				reference.Invalidate(&otherLocal);
+			});
+		}
+
+		[Test]
+		public unsafe void Invalidate_succeeds_if_address_match()
+		{
+			ReadOnlySpan<char> local = default;
+			var reference = new ByRefLikeReference(typeof(ReadOnlySpan<char>), &local);
+			reference.Invalidate(&local);
+		}
+
+		[Test]
+		public unsafe void GetPtr_throws_if_type_mismatch()
+		{
+			ReadOnlySpan<char> local = default;
+			var reference = new ByRefLikeReference(typeof(ReadOnlySpan<char>), &local);
+			Assert.Throws<AccessViolationException>(() => reference.GetPtr(typeof(bool)));
+		}
+
+		[Test]
+		public unsafe void GetPtr_returns_ctor_address_if_type_match()
+		{
+			ReadOnlySpan<char> local = default;
+			var reference = new ByRefLikeReference(typeof(ReadOnlySpan<char>), &local);
+			var ptr = reference.GetPtr(typeof(ReadOnlySpan<char>));
+			Assert.True(ptr == &local);
+		}
+
+		[Test]
+		public unsafe void GetPtr_throws_after_Invalidate()
+		{
+			ReadOnlySpan<char> local = default;
+			var reference = new ByRefLikeReference(typeof(ReadOnlySpan<char>), &local);
+			reference.Invalidate(&local);
+			Assert.Throws<AccessViolationException>(() => reference.GetPtr(typeof(ReadOnlySpan<char>)));
+		}
+
+		#endregion
+
+		#region `ReadOnlySpanReference<T>`
+
+		// We do not repeat the above tests for `ReadOnlySpanReference<T>`
+		// since it inherits the tested methods from `ByRefLikeReference`.
+
+		public unsafe void ReadOnlySpanReference_ctor_throws_if_type_mismatch()
+		{
+			Assert.Throws<ArgumentOutOfRangeException>(() =>
+			{
+				ReadOnlySpan<bool> local = default;
+				_ = new ReadOnlySpanReference<char>(typeof(ReadOnlySpan<bool>), &local);
+			});
+		}
+
+		public unsafe void ReadOnlySpanReference_Value_returns_equal_span()
+		{
+			ReadOnlySpan<char> local = "foo".AsSpan();
+			var reference = new ReadOnlySpanReference<char>(typeof(ReadOnlySpan<char>), &local);
+			Assert.True(reference.Value == "foo".AsSpan());
+		}
+
+#if NET9_0_OR_GREATER
+		[Test]
+		public unsafe void ReadOnlySpanReference_Value_returns_same_span()
+		{
+			ReadOnlySpan<char> local = "foo".AsSpan();
+			var reference = new ReadOnlySpanReference<char>(typeof(ReadOnlySpan<char>), &local);
+			Assert.True(Unsafe.AreSame(ref reference.Value, ref local));
+		}
+#endif
+
+		[Test]
+		public unsafe void ReadOnlySpanReference_Value_can_update_original()
+		{
+			ReadOnlySpan<char> local = "foo".AsSpan();
+			var reference = new ReadOnlySpanReference<char>(typeof(ReadOnlySpan<char>), &local);
+			reference.Value = "bar".AsSpan();
+			Assert.True(local == "bar".AsSpan());
+		}
+
+		#endregion
+
+		// We do not test `ByRefLikeReference<TByRefLike>` and `SpanReference<T>`
+		// since these two types are practically identical to `ReadOnlySpanReference<T>`.
+	}
+}
+
+#pragma warning restore CS8500
+
+#endif