Merge pull request #55 from siewers/main

Support CombinatorialMemberData for IEnumerable<string>

Author: AArnott

src/Xunit.Combinatorial/CombinatorialMemberDataAttribute.cs

@@ -204,22 +204,22 @@ private bool ParameterTypesCompatible(ParameterInfo[] parameters, object?[]? arg
         /// <exception cref="ArgumentException">Throw when <paramref name="enumerableType"/> does not conform to requirements or does not produce values assignable to <paramref name="parameterInfo"/>.</exception>
         private void EnsureValidMemberDataType(Type enumerableType, Type declaringType, ParameterInfo parameterInfo)
         {
-            TypeInfo enumerableTypeInfo = typeof(IEnumerable).GetTypeInfo();
-            if (!enumerableTypeInfo.IsAssignableFrom(enumerableType.GetTypeInfo()))
-            {
-                throw new ArgumentException($"Member {this.MemberName} on {declaringType.FullName} must return a type that implements {typeof(IEnumerable)}.");
-            }
-
             TypeInfo? enumeratedType = GetEnumeratedType(enumerableType);
             if (enumeratedType is null)
             {
                 throw new ArgumentException($"Member {this.MemberName} on {declaringType.FullName} must return a type that implements IEnumerable<T>.");
             }
 
-            if (enumerableTypeInfo.IsAssignableFrom(enumeratedType))
+            if (enumeratedType.IsArray)
+            {
+                throw new ArgumentException(
+                    $"Member {this.MemberName} on {declaringType.FullName} returned an IEnumerable<{enumeratedType.Name}>, which is not supported.");
+            }
+
+            if (enumeratedType.IsGenericType && enumeratedType.GetGenericTypeDefinition() == typeof(IEnumerable<>))
             {
                 throw new ArgumentException(
-                    $"Member {this.MemberName} on {declaringType.FullName} returned an IEnumerable<object[]>, which is not supported.");
+                    $"Member {this.MemberName} on {declaringType.FullName} returned an IEnumerable<IEnumerable<{enumeratedType.GetGenericArguments()[0].Name}>>, which is not supported.");
             }
 
             if (!enumeratedType.IsAssignableFrom(parameterInfo.ParameterType.GetTypeInfo()))

test/Xunit.Combinatorial.Tests/CombinatorialMemberDataAttributeTests.cs

@@ -9,6 +9,7 @@ public class CombinatorialMemberDataAttributeTests
 {
     private static readonly MethodInfo StubIntMethodInfo = typeof(CombinatorialMemberDataAttributeTests).GetMethod(nameof(StubIntMethod), BindingFlags.Instance | BindingFlags.NonPublic)!;
     private static readonly MethodInfo StubGuidMethodInfo = typeof(CombinatorialMemberDataAttributeTests).GetMethod(nameof(StubGuidMethod), BindingFlags.Instance | BindingFlags.NonPublic)!;
+    private static readonly MethodInfo StubStringMethodInfo = typeof(CombinatorialMemberDataAttributeTests).GetMethod(nameof(StubStringMethod), BindingFlags.Instance | BindingFlags.NonPublic)!;
 
     [Fact]
     public void EnumerableOfIntReturnsValues()
@@ -44,17 +45,17 @@ public void EnumerableOfArrayThrows()
         ParameterInfo parameter = StubIntMethodInfo.GetParameters()[0];
 
         ArgumentException? exception = Assert.Throws<ArgumentException>(() => attribute.GetValues(parameter));
-        Assert.Equal($"Member {nameof(GetValuesAsEnumerableOfIntArray)} on {nameof(CombinatorialMemberDataAttributeTests)} returned an IEnumerable<object[]>, which is not supported.", exception.Message);
+        Assert.Equal($"Member {nameof(GetValuesAsEnumerableOfIntArray)} on {nameof(CombinatorialMemberDataAttributeTests)} returned an IEnumerable<Int32[]>, which is not supported.", exception.Message);
     }
 
     [Fact]
-    public void NonEnumerableThrows()
+    public void EnumerableOfEnumerableThrows()
     {
-        var attribute = new CombinatorialMemberDataAttribute(nameof(GetValuesAsDoesNotImplementIEnumerable));
+        var attribute = new CombinatorialMemberDataAttribute(nameof(GetValuesAsEnumerableOfIntEnumerable));
         ParameterInfo parameter = StubIntMethodInfo.GetParameters()[0];
 
         ArgumentException? exception = Assert.Throws<ArgumentException>(() => attribute.GetValues(parameter));
-        Assert.Equal($"Member {nameof(GetValuesAsDoesNotImplementIEnumerable)} on {typeof(CombinatorialMemberDataAttributeTests)} must return a type that implements System.Collections.IEnumerable.", exception.Message);
+        Assert.Equal($"Member {nameof(GetValuesAsEnumerableOfIntEnumerable)} on {nameof(CombinatorialMemberDataAttributeTests)} returned an IEnumerable<IEnumerable<Int32>>, which is not supported.", exception.Message);
     }
 
     [Fact]
@@ -78,6 +79,16 @@ public void EnumerableOfGuidReturnsValue()
         Assert.Contains(values, obj => obj is Guid guid && guid != Guid.Empty);
     }
 
+    [Fact]
+    public void EnumerableOfStringReturnsValue()
+    {
+        var attribute = new CombinatorialMemberDataAttribute(nameof(GetValuesAsEnumerableOfString));
+        ParameterInfo parameter = StubStringMethodInfo.GetParameters()[0];
+        object?[]? values = attribute.GetValues(parameter);
+
+        Assert.Contains(values, obj => obj is string str && !string.IsNullOrEmpty(str));
+    }
+
     [Fact]
     public void IncompatibleMemberDataTypeThrows()
     {
@@ -100,8 +111,6 @@ private static IEnumerable<int> GetValuesAsEnumerableOfInt()
 
     private static ListOfInt GetValuesAsConcreteNonGenericClassImplementingEnumerableOfInt() => new ListOfInt { 1, 2, 3, 4 };
 
-    private static DoesNotImplementIEnumerable GetValuesAsDoesNotImplementIEnumerable() => new();
-
     private static ImplementsOnlyNonGenericIEnumerable GetValuesAsTypeThatImplementsNonGenericIEnumerable() => new();
 
     private static IEnumerable<int[]> GetValuesAsEnumerableOfIntArray()
@@ -113,6 +122,15 @@ private static IEnumerable<int[]> GetValuesAsEnumerableOfIntArray()
         yield return new[] { 5 };
     }
 
+    private static IEnumerable<IEnumerable<int>> GetValuesAsEnumerableOfIntEnumerable()
+    {
+        yield return new[] { 1 };
+        yield return new[] { 2 };
+        yield return new[] { 3 };
+        yield return new[] { 4 };
+        yield return new[] { 5 };
+    }
+
     private static IEnumerable<Guid> GetValuesAsEnumerableOfGuid()
     {
         yield return Guid.NewGuid();
@@ -122,6 +140,15 @@ private static IEnumerable<Guid> GetValuesAsEnumerableOfGuid()
         yield return Guid.NewGuid();
     }
 
+    private static IEnumerable<string> GetValuesAsEnumerableOfString()
+    {
+        yield return Guid.NewGuid().ToString();
+        yield return Guid.NewGuid().ToString();
+        yield return Guid.NewGuid().ToString();
+        yield return Guid.NewGuid().ToString();
+        yield return Guid.NewGuid().ToString();
+    }
+
     private void StubIntMethod(int p1)
     {
     }
@@ -130,6 +157,10 @@ private void StubGuidMethod(Guid p1)
     {
     }
 
+    private void StubStringMethod(string p1)
+    {
+    }
+
     private class ListOfInt : List<int>
     {
     }