Update generic IReference tests to assert NotSupportedException

The collection cases over 'IReference<TypeName>' / 'IReference<HResult>' cannot be
marshalled, so the projection now emits a throwing body for them. Update the four
generic tests to validate that calling these projected members throws
'NotSupportedException', covering both the return-only and parameter directions for
each type, and rename them to reflect the asserted behavior.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Sergio0694

src/Tests/UnitTest/TestComponentCSharp_Tests.cs

@@ -3787,47 +3787,39 @@ public void ReferenceHResultProjectsAsException()
         }
 
         [TestMethod]
-        public void ReferenceTypeNameListProjectsAsTypeList()
+        public void ReferenceTypeNameListReturnThrowsNotSupported()
         {
-            // 'IVector<IReference<TypeName>>' projects to the public 'IList<Type>', but the ABI marshaller keeps
-            // the 'Nullable<Type>' element marker, so it targets the correct 'IVector<IReference<TypeName>>' IID
-            // and boxes/unboxes each element via 'TypeMarshaller'. The list returned from native round-trips with
-            // usable 'Type' elements (this is the return-only direction, created entirely in C++).
-            IList<Type> list = Class.GetReferenceTypeNameList();
-
-            Assert.AreEqual(2, list.Count);
-            Assert.AreEqual(typeof(Class), list[0]);
-            Assert.AreEqual(typeof(int), list[1]);
+            // 'IVector<IReference<TypeName>>' projects its public surface as 'IList<Type>', but it cannot be
+            // marshalled: 'System.Type' is a reference type, so there is no valid 'Nullable<Type>' collection
+            // marshaller for the interop generator to produce. The projected member throws 'NotSupportedException'
+            // instead of referencing a marshaller that does not exist (return-only direction, created in C++)
+            Assert.ThrowsExactly<NotSupportedException>(() => Class.GetReferenceTypeNameList());
         }
 
         [TestMethod]
-        public void ReferenceTypeNameListAsParameter()
+        public void ReferenceTypeNameListParameterThrowsNotSupported()
         {
-            // Passing a managed 'IList<Type>' to a native 'IVector<IReference<TypeName>>' parameter (the native
-            // side only reads the count here, which is element-agnostic)
-            Assert.AreEqual(2, Class.CountReferenceTypeNameList(new List<Type> { typeof(Class), typeof(int) }));
+            // Same limitation as the return direction: passing a managed 'IList<Type>' to a native
+            // 'IVector<IReference<TypeName>>' parameter throws 'NotSupportedException'
+            Assert.ThrowsExactly<NotSupportedException>(() => Class.CountReferenceTypeNameList(new List<Type> { typeof(Class), typeof(int) }));
         }
 
         [TestMethod]
-        public void ReferenceHResultListProjectsAsExceptionList()
+        public void ReferenceHResultListReturnThrowsNotSupported()
         {
-            // 'IVector<IReference<HResult>>' projects to the public 'IList<Exception>', but the ABI marshaller keeps
-            // the 'Nullable<Exception>' element marker, so it targets the correct 'IVector<IReference<HResult>>' IID
-            // and boxes/unboxes each element via 'ExceptionMarshaller'. The list returned from native round-trips
-            // with usable 'Exception' elements (this is the return-only direction, created entirely in C++).
-            IList<Exception> list = Class.GetReferenceHResultList();
-
-            Assert.AreEqual(1, list.Count);
-            Assert.IsNotNull(list[0]);
-            Assert.AreEqual(unchecked((int)0x80070057), list[0].HResult); // 'E_INVALIDARG'
+            // 'IVector<IReference<HResult>>' projects its public surface as 'IList<Exception>', but it cannot be
+            // marshalled: 'System.Exception' is a reference type, so there is no valid 'Nullable<Exception>' collection
+            // marshaller for the interop generator to produce. The projected member throws 'NotSupportedException'
+            // instead of referencing a marshaller that does not exist (return-only direction, created in C++)
+            Assert.ThrowsExactly<NotSupportedException>(() => Class.GetReferenceHResultList());
         }
 
         [TestMethod]
-        public void ReferenceHResultListAsParameter()
+        public void ReferenceHResultListParameterThrowsNotSupported()
         {
-            // Passing a managed 'IList<Exception>' to a native 'IVector<IReference<HResult>>' parameter (the native
-            // side only reads the count here, which is element-agnostic)
-            Assert.AreEqual(2, Class.CountReferenceHResultList(new List<Exception> { new ArgumentException(), new InvalidOperationException() }));
+            // Same limitation as the return direction: passing a managed 'IList<Exception>' to a native
+            // 'IVector<IReference<HResult>>' parameter throws 'NotSupportedException'
+            Assert.ThrowsExactly<NotSupportedException>(() => Class.CountReferenceHResultList(new List<Exception> { new ArgumentException(), new InvalidOperationException() }));
         }
 
         [TestMethod]