Add more unit tests for generics collections

- Tests calling a private static generic helper method that produces a MethodSpec with MVAR type arguments.

Author: josesimoes

Tests/GenericCollections/ListTests.cs

@@ -847,6 +847,236 @@ public void List_LargeCapacity_Growth()
                 Assert.AreEqual(i, list[i]);
             }
         }
+
+        [TestMethod]
+        public void List_GenericMethod_Foreach_Int()
+        {
+            // Exercises MVAR resolution: a generic method creates List<T> and iterates via foreach.
+            // The virtual dispatch of MoveNext()/Current on IEnumerator<T> requires resolving
+            // !!T (method-level generic parameter) through the caller's MethodSpec context.
+            int result = SumList(new int[] { 1, 2, 3, 4, 5 });
+            Assert.AreEqual(15, result);
+        }
+
+        [TestMethod]
+        public void List_GenericMethod_Foreach_String()
+        {
+            // Same MVAR path but with reference types
+            string result = ConcatList(new string[] { "Hello", " ", "World" });
+            Assert.AreEqual("Hello World", result);
+        }
+
+        [TestMethod]
+        public void List_GenericMethod_Foreach_Class()
+        {
+            // MVAR resolution with user-defined class types
+            var items = new DummyClass[]
+            {
+                new(1, "One"),
+                new(2, "Two"),
+                new(3, "Three")
+            };
+
+            var result = CollectFromList(items);
+            Assert.AreEqual(3, result.Length);
+            Assert.AreEqual(1, result[0].Id);
+            Assert.AreEqual("Two", result[1].Name);
+            Assert.AreEqual(3, result[2].Id);
+        }
+
+        [TestMethod]
+        public void List_GenericMethod_Contains()
+        {
+            // Exercises MVAR resolution through Contains which uses
+            // equality checks on the generic type parameter
+            Assert.IsTrue(ListContains(new int[] { 1, 2, 3 }, 2));
+            Assert.IsFalse(ListContains(new int[] { 1, 2, 3 }, 5));
+
+            Assert.IsTrue(ListContains(new string[] { "A", "B", "C" }, "B"));
+            Assert.IsFalse(ListContains(new string[] { "A", "B", "C" }, "Z"));
+        }
+
+        [TestMethod]
+        public void List_GenericMethod_AddAndCount()
+        {
+            // Exercises MVAR resolution through Add/Count on List<T>
+            // where T is a method-level generic parameter
+            Assert.AreEqual(5, BuildListAndCount(1, 2, 3, 4, 5));
+            Assert.AreEqual(3, BuildListAndCount("A", "B", "C"));
+        }
+
+        [TestMethod]
+        public void List_GenericMethod_IndexOf()
+        {
+            // Exercises MVAR resolution through IndexOf
+            Assert.AreEqual(2, ListIndexOf(new int[] { 10, 20, 30, 40 }, 30));
+            Assert.AreEqual(-1, ListIndexOf(new int[] { 10, 20, 30, 40 }, 99));
+
+            Assert.AreEqual(1, ListIndexOf(new string[] { "X", "Y", "Z" }, "Y"));
+            Assert.AreEqual(-1, ListIndexOf(new string[] { "X", "Y", "Z" }, "W"));
+        }
+
+        [TestMethod]
+        public void List_GenericMethod_RemoveAndVerify()
+        {
+            // Exercises MVAR resolution through Remove + foreach verification
+            var remaining = RemoveFromList(new int[] { 1, 2, 3, 4, 5 }, 3);
+            Assert.AreEqual(4, remaining.Length);
+            Assert.AreEqual(1, remaining[0]);
+            Assert.AreEqual(2, remaining[1]);
+            Assert.AreEqual(4, remaining[2]);
+            Assert.AreEqual(5, remaining[3]);
+        }
+
+        [TestMethod]
+        public void List_GenericMethod_InsertAndIterate()
+        {
+            // Exercises MVAR resolution through Insert + foreach iteration
+            var result = InsertIntoList(new int[] { 1, 3, 4 }, 1, 2);
+            Assert.AreEqual(4, result.Length);
+            Assert.AreEqual(1, result[0]);
+            Assert.AreEqual(2, result[1]);
+            Assert.AreEqual(3, result[2]);
+            Assert.AreEqual(4, result[3]);
+        }
+
+        [TestMethod]
+        public void List_GenericMethod_NestedIteration()
+        {
+            // Exercises MVAR resolution with nested generic method calls
+            // The inner method iterates a List<T> created from the outer method's !!T
+            var list = new List<int> { 1, 2, 3 };
+            int sum = IterateAndSum(list);
+            Assert.AreEqual(6, sum);
+
+            var listStr = new List<string> { "A", "B", "C" };
+            int count = CountItems(listStr);
+            Assert.AreEqual(3, count);
+        }
+
+        // Generic helper methods that exercise MVAR resolution paths.
+        // When these are called, the TypeSpec for List<T> contains !!T (MVAR)
+        // which must be resolved from the caller's MethodSpec context.
+
+        private static int SumList<T>(T[] source) where T : struct
+        {
+            var list = new List<T>(source);
+            int sum = 0;
+
+            foreach (T item in list)
+            {
+                sum += (int)(object)item;
+            }
+
+            return sum;
+        }
+
+        private static string ConcatList<T>(T[] source)
+        {
+            var list = new List<T>(source);
+            string result = "";
+
+            foreach (T item in list)
+            {
+                result += item.ToString();
+            }
+
+            return result;
+        }
+
+        private static T[] CollectFromList<T>(T[] source)
+        {
+            var list = new List<T>(source);
+            var result = new T[list.Count];
+            int i = 0;
+
+            foreach (T item in list)
+            {
+                result[i++] = item;
+            }
+
+            return result;
+        }
+
+        private static bool ListContains<T>(T[] source, T value)
+        {
+            var list = new List<T>(source);
+            return list.Contains(value);
+        }
+
+        private static int BuildListAndCount<T>(params T[] items)
+        {
+            var list = new List<T>();
+
+            foreach (T item in items)
+            {
+                list.Add(item);
+            }
+
+            return list.Count;
+        }
+
+        private static int ListIndexOf<T>(T[] source, T value)
+        {
+            var list = new List<T>(source);
+            return list.IndexOf(value);
+        }
+
+        private static T[] RemoveFromList<T>(T[] source, T itemToRemove)
+        {
+            var list = new List<T>(source);
+            list.Remove(itemToRemove);
+
+            var result = new T[list.Count];
+            int i = 0;
+
+            foreach (T item in list)
+            {
+                result[i++] = item;
+            }
+
+            return result;
+        }
+
+        private static T[] InsertIntoList<T>(T[] source, int index, T item)
+        {
+            var list = new List<T>(source);
+            list.Insert(index, item);
+
+            var result = new T[list.Count];
+            int i = 0;
+
+            foreach (T entry in list)
+            {
+                result[i++] = entry;
+            }
+
+            return result;
+        }
+
+        private static int IterateAndSum<T>(List<T> list) where T : struct
+        {
+            int sum = 0;
+
+            foreach (T item in list)
+            {
+                sum += (int)(object)item;
+            }
+
+            return sum;
+        }
+
+        private static int CountItems<T>(List<T> list)
+        {
+            int count = 0;
+
+            foreach (T _ in list)
+            {
+                count++;
+            }
+
+            return count;
+        }
     }
 
     internal class DummyClass