diff --git a/TUnit.Core.SourceGenerator.Tests/ArgsAsArrayTests.Test.verified.txt b/TUnit.Core.SourceGenerator.Tests/ArgsAsArrayTests.Test.verified.txt index 4bd714eb7b..3b7a6fa3f8 100644 --- a/TUnit.Core.SourceGenerator.Tests/ArgsAsArrayTests.Test.verified.txt +++ b/TUnit.Core.SourceGenerator.Tests/ArgsAsArrayTests.Test.verified.txt @@ -1,4 +1,4 @@ -// +// #pragma warning disable #nullable enable @@ -31,6 +31,30 @@ global::TUnit.Core.ParameterMetadataFactory.Create(typeof(global::System.Collect { global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "i", new global::TUnit.Core.ConcreteType(typeof(int)), false, reflectionInfoFactory: static () => typeof(global::TUnit.TestProject.ArgsAsArrayTests).GetMethod("Following_Non_Params", global::System.Reflection.BindingFlags.Public | global::System.Reflection.BindingFlags.NonPublic | global::System.Reflection.BindingFlags.Instance, null, new global::System.Type[] { typeof(int), typeof(global::System.Collections.Generic.IEnumerable) }, null)!.GetParameters()[0]), global::TUnit.Core.ParameterMetadataFactory.Create(typeof(global::System.Collections.Generic.IEnumerable), "arguments", new global::TUnit.Core.ConcreteType(typeof(global::System.Collections.Generic.IEnumerable)), false, reflectionInfoFactory: static () => typeof(global::TUnit.TestProject.ArgsAsArrayTests).GetMethod("Following_Non_Params", global::System.Reflection.BindingFlags.Public | global::System.Reflection.BindingFlags.NonPublic | global::System.Reflection.BindingFlags.Instance, null, new global::System.Type[] { typeof(int), typeof(global::System.Collections.Generic.IEnumerable) }, null)!.GetParameters()[1]) +}); + private static readonly global::TUnit.Core.MethodMetadata __mm_3 = global::TUnit.Core.MethodMetadataFactory.Create("NonParamsStringArray", __classType, typeof(global::System.Threading.Tasks.Task), __classMetadata, parameters: new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(string[]), "names", new global::TUnit.Core.ConcreteType(typeof(string[])), false, reflectionInfoFactory: static () => typeof(global::TUnit.TestProject.ArgsAsArrayTests).GetMethod("NonParamsStringArray", global::System.Reflection.BindingFlags.Public | global::System.Reflection.BindingFlags.NonPublic | global::System.Reflection.BindingFlags.Instance, null, new global::System.Type[] { typeof(string[]) }, null)!.GetParameters()[0]) +}); + private static readonly global::TUnit.Core.MethodMetadata __mm_4 = global::TUnit.Core.MethodMetadataFactory.Create("NonParamsStringArray_SingleValue", __classType, typeof(global::System.Threading.Tasks.Task), __classMetadata, parameters: new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(string[]), "names", new global::TUnit.Core.ConcreteType(typeof(string[])), false, reflectionInfoFactory: static () => typeof(global::TUnit.TestProject.ArgsAsArrayTests).GetMethod("NonParamsStringArray_SingleValue", global::System.Reflection.BindingFlags.Public | global::System.Reflection.BindingFlags.NonPublic | global::System.Reflection.BindingFlags.Instance, null, new global::System.Type[] { typeof(string[]) }, null)!.GetParameters()[0]) +}); + private static readonly global::TUnit.Core.MethodMetadata __mm_5 = global::TUnit.Core.MethodMetadataFactory.Create("NonParamsStringArray_MultipleValues", __classType, typeof(global::System.Threading.Tasks.Task), __classMetadata, parameters: new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(string[]), "names", new global::TUnit.Core.ConcreteType(typeof(string[])), false, reflectionInfoFactory: static () => typeof(global::TUnit.TestProject.ArgsAsArrayTests).GetMethod("NonParamsStringArray_MultipleValues", global::System.Reflection.BindingFlags.Public | global::System.Reflection.BindingFlags.NonPublic | global::System.Reflection.BindingFlags.Instance, null, new global::System.Type[] { typeof(string[]) }, null)!.GetParameters()[0]) +}); + private static readonly global::TUnit.Core.MethodMetadata __mm_6 = global::TUnit.Core.MethodMetadataFactory.Create("NonParamsIntArray", __classType, typeof(global::System.Threading.Tasks.Task), __classMetadata, parameters: new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "numbers", new global::TUnit.Core.ConcreteType(typeof(int[])), false, reflectionInfoFactory: static () => typeof(global::TUnit.TestProject.ArgsAsArrayTests).GetMethod("NonParamsIntArray", global::System.Reflection.BindingFlags.Public | global::System.Reflection.BindingFlags.NonPublic | global::System.Reflection.BindingFlags.Instance, null, new global::System.Type[] { typeof(int[]) }, null)!.GetParameters()[0]) +}); + private static readonly global::TUnit.Core.MethodMetadata __mm_7 = global::TUnit.Core.MethodMetadataFactory.Create("GenericStringArray", __classType, typeof(global::System.Threading.Tasks.Task), __classMetadata, parameters: new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(string[]), "names", new global::TUnit.Core.ConcreteType(typeof(string[])), false, reflectionInfoFactory: static () => typeof(global::TUnit.TestProject.ArgsAsArrayTests).GetMethod("GenericStringArray", global::System.Reflection.BindingFlags.Public | global::System.Reflection.BindingFlags.NonPublic | global::System.Reflection.BindingFlags.Instance, null, new global::System.Type[] { typeof(string[]) }, null)!.GetParameters()[0]) +}); + private static readonly global::TUnit.Core.MethodMetadata __mm_8 = global::TUnit.Core.MethodMetadataFactory.Create("NonParamsStringArray_BeyondStaticCaseCap", __classType, typeof(global::System.Threading.Tasks.Task), __classMetadata, parameters: new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(string[]), "names", new global::TUnit.Core.ConcreteType(typeof(string[])), false, reflectionInfoFactory: static () => typeof(global::TUnit.TestProject.ArgsAsArrayTests).GetMethod("NonParamsStringArray_BeyondStaticCaseCap", global::System.Reflection.BindingFlags.Public | global::System.Reflection.BindingFlags.NonPublic | global::System.Reflection.BindingFlags.Instance, null, new global::System.Type[] { typeof(string[]) }, null)!.GetParameters()[0]) }); private static global::TUnit.TestProject.ArgsAsArrayTests __CreateInstance(global::System.Type[] typeArgs, object?[] args) { @@ -82,7 +106,8 @@ global::TUnit.Core.ParameterMetadataFactory.Create(typeof(global::System.Collect return default(global::System.Threading.Tasks.ValueTask); } default: - throw new global::System.ArgumentException($"Expected between 0 and 1 arguments, but got {args.Length}"); + instance.Params((args.Length > 0 ? global::System.Linq.Enumerable.Range(0, args.Length).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new string[0])); + return default(global::System.Threading.Tasks.ValueTask); } } catch (global::System.Exception ex) @@ -98,41 +123,42 @@ global::TUnit.Core.ParameterMetadataFactory.Create(typeof(global::System.Collect { case 0: { - instance.ParamsEnumerable(global::TUnit.Core.Helpers.CastHelper.Cast>(args[0])); + instance.ParamsEnumerable(new string[0]); return default(global::System.Threading.Tasks.ValueTask); } case 1: { - instance.ParamsEnumerable(global::TUnit.Core.Helpers.CastHelper.Cast>(args[0])); + instance.ParamsEnumerable((args[0] is null ? null : args[0] is global::System.Collections.Generic.IEnumerable arr ? arr : new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]) })); return default(global::System.Threading.Tasks.ValueTask); } case 2: { - instance.ParamsEnumerable(global::TUnit.Core.Helpers.CastHelper.Cast>(args[0])); + instance.ParamsEnumerable(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]) }); return default(global::System.Threading.Tasks.ValueTask); } case 3: { - instance.ParamsEnumerable(global::TUnit.Core.Helpers.CastHelper.Cast>(args[0])); + instance.ParamsEnumerable(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]) }); return default(global::System.Threading.Tasks.ValueTask); } case 4: { - instance.ParamsEnumerable(global::TUnit.Core.Helpers.CastHelper.Cast>(args[0])); + instance.ParamsEnumerable(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]) }); return default(global::System.Threading.Tasks.ValueTask); } case 5: { - instance.ParamsEnumerable(global::TUnit.Core.Helpers.CastHelper.Cast>(args[0])); + instance.ParamsEnumerable(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]) }); return default(global::System.Threading.Tasks.ValueTask); } case 6: { - instance.ParamsEnumerable(global::TUnit.Core.Helpers.CastHelper.Cast>(args[0])); + instance.ParamsEnumerable(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast(args[5]) }); return default(global::System.Threading.Tasks.ValueTask); } default: - throw new global::System.ArgumentException($"Expected between 0 and 1 arguments, but got {args.Length}"); + instance.ParamsEnumerable((args.Length > 0 ? global::System.Linq.Enumerable.Range(0, args.Length).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new string[0])); + return default(global::System.Threading.Tasks.ValueTask); } } catch (global::System.Exception ex) @@ -148,41 +174,304 @@ global::TUnit.Core.ParameterMetadataFactory.Create(typeof(global::System.Collect { case 1: { - instance.Following_Non_Params(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(args[1])); + instance.Following_Non_Params(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), new string[0]); return default(global::System.Threading.Tasks.ValueTask); } case 2: { - instance.Following_Non_Params(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(args[1])); + instance.Following_Non_Params(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), (args[1] is null ? null : args[1] is global::System.Collections.Generic.IEnumerable arr ? arr : new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[1]) })); return default(global::System.Threading.Tasks.ValueTask); } case 3: { - instance.Following_Non_Params(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(args[1])); + instance.Following_Non_Params(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]) }); return default(global::System.Threading.Tasks.ValueTask); } case 4: { - instance.Following_Non_Params(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(args[1])); + instance.Following_Non_Params(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]) }); return default(global::System.Threading.Tasks.ValueTask); } case 5: { - instance.Following_Non_Params(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(args[1])); + instance.Following_Non_Params(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]) }); return default(global::System.Threading.Tasks.ValueTask); } case 6: { - instance.Following_Non_Params(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(args[1])); + instance.Following_Non_Params(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast(args[5]) }); return default(global::System.Threading.Tasks.ValueTask); } case 7: { - instance.Following_Non_Params(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(args[1])); + instance.Following_Non_Params(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast(args[5]), global::TUnit.Core.Helpers.CastHelper.Cast(args[6]) }); return default(global::System.Threading.Tasks.ValueTask); } default: - throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + if (args.Length < 1) + { + throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}"); + } + instance.Following_Non_Params(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), (args.Length > 1 ? global::System.Linq.Enumerable.Range(1, args.Length - 1).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new string[0])); + return default(global::System.Threading.Tasks.ValueTask); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + case 3: + { + try + { + switch (args.Length) + { + case 0: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray(new string[0])); + } + case 1: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray((args[0] is null ? null : args[0] is string[] arr ? arr : new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]) }))); + } + case 2: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]) })); + } + case 3: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]) })); + } + case 4: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]) })); + } + case 5: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]) })); + } + case 6: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast(args[5]) })); + } + default: + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray((args.Length > 0 ? global::System.Linq.Enumerable.Range(0, args.Length).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new string[0]))); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + case 4: + { + try + { + switch (args.Length) + { + case 0: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_SingleValue(new string[0])); + } + case 1: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_SingleValue((args[0] is null ? null : args[0] is string[] arr ? arr : new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]) }))); + } + case 2: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_SingleValue(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]) })); + } + case 3: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_SingleValue(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]) })); + } + case 4: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_SingleValue(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]) })); + } + case 5: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_SingleValue(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]) })); + } + case 6: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_SingleValue(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast(args[5]) })); + } + default: + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_SingleValue((args.Length > 0 ? global::System.Linq.Enumerable.Range(0, args.Length).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new string[0]))); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + case 5: + { + try + { + switch (args.Length) + { + case 0: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_MultipleValues(new string[0])); + } + case 1: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_MultipleValues((args[0] is null ? null : args[0] is string[] arr ? arr : new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]) }))); + } + case 2: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_MultipleValues(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]) })); + } + case 3: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_MultipleValues(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]) })); + } + case 4: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_MultipleValues(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]) })); + } + case 5: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_MultipleValues(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]) })); + } + case 6: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_MultipleValues(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast(args[5]) })); + } + default: + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_MultipleValues((args.Length > 0 ? global::System.Linq.Enumerable.Range(0, args.Length).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new string[0]))); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + case 6: + { + try + { + switch (args.Length) + { + case 0: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsIntArray(new int[0])); + } + case 1: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsIntArray((args[0] is null ? null : args[0] is int[] arr ? arr : new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]) }))); + } + case 2: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsIntArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]) })); + } + case 3: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsIntArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]) })); + } + case 4: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsIntArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]) })); + } + case 5: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsIntArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]) })); + } + case 6: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsIntArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast(args[5]) })); + } + default: + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsIntArray((args.Length > 0 ? global::System.Linq.Enumerable.Range(0, args.Length).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new int[0]))); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + case 7: + { + try + { + switch (args.Length) + { + case 0: + { + return new global::System.Threading.Tasks.ValueTask(instance.GenericStringArray(new string[0])); + } + case 1: + { + return new global::System.Threading.Tasks.ValueTask(instance.GenericStringArray((args[0] is null ? null : args[0] is string[] arr ? arr : new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]) }))); + } + case 2: + { + return new global::System.Threading.Tasks.ValueTask(instance.GenericStringArray(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]) })); + } + case 3: + { + return new global::System.Threading.Tasks.ValueTask(instance.GenericStringArray(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]) })); + } + case 4: + { + return new global::System.Threading.Tasks.ValueTask(instance.GenericStringArray(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]) })); + } + case 5: + { + return new global::System.Threading.Tasks.ValueTask(instance.GenericStringArray(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]) })); + } + case 6: + { + return new global::System.Threading.Tasks.ValueTask(instance.GenericStringArray(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast(args[5]) })); + } + default: + return new global::System.Threading.Tasks.ValueTask(instance.GenericStringArray((args.Length > 0 ? global::System.Linq.Enumerable.Range(0, args.Length).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new string[0]))); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + case 8: + { + try + { + switch (args.Length) + { + case 0: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_BeyondStaticCaseCap(new string[0])); + } + case 1: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_BeyondStaticCaseCap((args[0] is null ? null : args[0] is string[] arr ? arr : new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]) }))); + } + case 2: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_BeyondStaticCaseCap(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]) })); + } + case 3: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_BeyondStaticCaseCap(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]) })); + } + case 4: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_BeyondStaticCaseCap(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]) })); + } + case 5: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_BeyondStaticCaseCap(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]) })); + } + case 6: + { + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_BeyondStaticCaseCap(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast(args[5]) })); + } + default: + return new global::System.Threading.Tasks.ValueTask(instance.NonParamsStringArray_BeyondStaticCaseCap((args.Length > 0 ? global::System.Linq.Enumerable.Range(0, args.Length).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new string[0]))); } } catch (global::System.Exception ex) @@ -275,6 +564,139 @@ global::TUnit.Core.ParameterMetadataFactory.Create(typeof(global::System.Collect TestDataSources = new global::TUnit.Core.IDataSourceAttribute[] { new global::TUnit.Core.ArgumentsAttribute(1, "arg1", "arg2", "arg3"), +}, + }, + new global::TUnit.Core.TestEntry + { + MethodName = "NonParamsStringArray", + FullyQualifiedName = "TUnit.TestProject.ArgsAsArrayTests.NonParamsStringArray", + FilePath = @"", + LineNumber = 38, + Categories = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + HasDataSource = true, + RepeatCount = 0, + DependsOn = global::System.Array.Empty(), + MethodMetadata = __mm_3, + CreateInstance = __CreateInstance, + InvokeBody = __Invoke, + MethodIndex = 3, + CreateAttributes = __Attributes, + AttributeGroupIndex = 0, + TestDataSources = new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.ArgumentsAttribute(new object[]{"Chloe"}), + new global::TUnit.Core.ArgumentsAttribute(new object[]{"Skipper","Lucy"}), +}, + }, + new global::TUnit.Core.TestEntry + { + MethodName = "NonParamsStringArray_SingleValue", + FullyQualifiedName = "TUnit.TestProject.ArgsAsArrayTests.NonParamsStringArray_SingleValue", + FilePath = @"", + LineNumber = 47, + Categories = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + HasDataSource = true, + RepeatCount = 0, + DependsOn = global::System.Array.Empty(), + MethodMetadata = __mm_4, + CreateInstance = __CreateInstance, + InvokeBody = __Invoke, + MethodIndex = 4, + CreateAttributes = __Attributes, + AttributeGroupIndex = 0, + TestDataSources = new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.ArgumentsAttribute("Chloe"), +}, + }, + new global::TUnit.Core.TestEntry + { + MethodName = "NonParamsStringArray_MultipleValues", + FullyQualifiedName = "TUnit.TestProject.ArgsAsArrayTests.NonParamsStringArray_MultipleValues", + FilePath = @"", + LineNumber = 54, + Categories = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + HasDataSource = true, + RepeatCount = 0, + DependsOn = global::System.Array.Empty(), + MethodMetadata = __mm_5, + CreateInstance = __CreateInstance, + InvokeBody = __Invoke, + MethodIndex = 5, + CreateAttributes = __Attributes, + AttributeGroupIndex = 0, + TestDataSources = new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.ArgumentsAttribute(new object[]{"Skipper","Lucy"}), +}, + }, + new global::TUnit.Core.TestEntry + { + MethodName = "NonParamsIntArray", + FullyQualifiedName = "TUnit.TestProject.ArgsAsArrayTests.NonParamsIntArray", + FilePath = @"", + LineNumber = 61, + Categories = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + HasDataSource = true, + RepeatCount = 0, + DependsOn = global::System.Array.Empty(), + MethodMetadata = __mm_6, + CreateInstance = __CreateInstance, + InvokeBody = __Invoke, + MethodIndex = 6, + CreateAttributes = __Attributes, + AttributeGroupIndex = 0, + TestDataSources = new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.ArgumentsAttribute(1, 2, 3), +}, + }, + new global::TUnit.Core.TestEntry + { + MethodName = "GenericStringArray", + FullyQualifiedName = "TUnit.TestProject.ArgsAsArrayTests.GenericStringArray", + FilePath = @"", + LineNumber = 69, + Categories = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + HasDataSource = true, + RepeatCount = 0, + DependsOn = global::System.Array.Empty(), + MethodMetadata = __mm_7, + CreateInstance = __CreateInstance, + InvokeBody = __Invoke, + MethodIndex = 7, + CreateAttributes = __Attributes, + AttributeGroupIndex = 0, + TestDataSources = new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.ArgumentsAttribute(new string[]{"Skipper","Lucy"}), +}, + }, + new global::TUnit.Core.TestEntry + { + MethodName = "NonParamsStringArray_BeyondStaticCaseCap", + FullyQualifiedName = "TUnit.TestProject.ArgsAsArrayTests.NonParamsStringArray_BeyondStaticCaseCap", + FilePath = @"", + LineNumber = 78, + Categories = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + HasDataSource = true, + RepeatCount = 0, + DependsOn = global::System.Array.Empty(), + MethodMetadata = __mm_8, + CreateInstance = __CreateInstance, + InvokeBody = __Invoke, + MethodIndex = 8, + CreateAttributes = __Attributes, + AttributeGroupIndex = 0, + TestDataSources = new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.ArgumentsAttribute("a", "b", "c", "d", "e", "f", "g", "h"), }, }, }; diff --git a/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.DataDrivenTest_WithConflictingNamespace.DotNet10_0.verified.txt b/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.DataDrivenTest_WithConflictingNamespace.DotNet10_0.verified.txt index d755ba780c..4aa3da7152 100644 --- a/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.DataDrivenTest_WithConflictingNamespace.DotNet10_0.verified.txt +++ b/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.DataDrivenTest_WithConflictingNamespace.DotNet10_0.verified.txt @@ -234,13 +234,44 @@ global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "value", new glo { switch (args.Length) { + case 0: + { + instance.IntegerArray(new int[0]); + return default(global::System.Threading.Tasks.ValueTask); + } case 1: { - instance.IntegerArray(global::TUnit.Core.Helpers.CastHelper.Cast(args[0])); + instance.IntegerArray((args[0] is null ? null : args[0] is int[] arr ? arr : new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]) })); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]) }); + return default(global::System.Threading.Tasks.ValueTask); + } + case 3: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]) }); + return default(global::System.Threading.Tasks.ValueTask); + } + case 4: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]) }); + return default(global::System.Threading.Tasks.ValueTask); + } + case 5: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]) }); + return default(global::System.Threading.Tasks.ValueTask); + } + case 6: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast(args[5]) }); return default(global::System.Threading.Tasks.ValueTask); } default: - throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + instance.IntegerArray((args.Length > 0 ? global::System.Linq.Enumerable.Range(0, args.Length).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new int[0])); + return default(global::System.Threading.Tasks.ValueTask); } } catch (global::System.Exception ex) diff --git a/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.DataDrivenTest_WithConflictingNamespace.DotNet8_0.verified.txt b/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.DataDrivenTest_WithConflictingNamespace.DotNet8_0.verified.txt index d755ba780c..4aa3da7152 100644 --- a/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.DataDrivenTest_WithConflictingNamespace.DotNet8_0.verified.txt +++ b/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.DataDrivenTest_WithConflictingNamespace.DotNet8_0.verified.txt @@ -234,13 +234,44 @@ global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "value", new glo { switch (args.Length) { + case 0: + { + instance.IntegerArray(new int[0]); + return default(global::System.Threading.Tasks.ValueTask); + } case 1: { - instance.IntegerArray(global::TUnit.Core.Helpers.CastHelper.Cast(args[0])); + instance.IntegerArray((args[0] is null ? null : args[0] is int[] arr ? arr : new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]) })); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]) }); + return default(global::System.Threading.Tasks.ValueTask); + } + case 3: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]) }); + return default(global::System.Threading.Tasks.ValueTask); + } + case 4: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]) }); + return default(global::System.Threading.Tasks.ValueTask); + } + case 5: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]) }); + return default(global::System.Threading.Tasks.ValueTask); + } + case 6: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast(args[5]) }); return default(global::System.Threading.Tasks.ValueTask); } default: - throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + instance.IntegerArray((args.Length > 0 ? global::System.Linq.Enumerable.Range(0, args.Length).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new int[0])); + return default(global::System.Threading.Tasks.ValueTask); } } catch (global::System.Exception ex) diff --git a/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.DataDrivenTest_WithConflictingNamespace.DotNet9_0.verified.txt b/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.DataDrivenTest_WithConflictingNamespace.DotNet9_0.verified.txt index d755ba780c..4aa3da7152 100644 --- a/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.DataDrivenTest_WithConflictingNamespace.DotNet9_0.verified.txt +++ b/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.DataDrivenTest_WithConflictingNamespace.DotNet9_0.verified.txt @@ -234,13 +234,44 @@ global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "value", new glo { switch (args.Length) { + case 0: + { + instance.IntegerArray(new int[0]); + return default(global::System.Threading.Tasks.ValueTask); + } case 1: { - instance.IntegerArray(global::TUnit.Core.Helpers.CastHelper.Cast(args[0])); + instance.IntegerArray((args[0] is null ? null : args[0] is int[] arr ? arr : new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]) })); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]) }); + return default(global::System.Threading.Tasks.ValueTask); + } + case 3: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]) }); + return default(global::System.Threading.Tasks.ValueTask); + } + case 4: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]) }); + return default(global::System.Threading.Tasks.ValueTask); + } + case 5: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]) }); + return default(global::System.Threading.Tasks.ValueTask); + } + case 6: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast(args[5]) }); return default(global::System.Threading.Tasks.ValueTask); } default: - throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + instance.IntegerArray((args.Length > 0 ? global::System.Linq.Enumerable.Range(0, args.Length).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new int[0])); + return default(global::System.Threading.Tasks.ValueTask); } } catch (global::System.Exception ex) diff --git a/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.DataDrivenTest_WithConflictingNamespace.Net4_7.verified.txt b/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.DataDrivenTest_WithConflictingNamespace.Net4_7.verified.txt index d1793df3ab..99ac2392d3 100644 --- a/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.DataDrivenTest_WithConflictingNamespace.Net4_7.verified.txt +++ b/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.DataDrivenTest_WithConflictingNamespace.Net4_7.verified.txt @@ -234,13 +234,44 @@ global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "value", new glo { switch (args.Length) { + case 0: + { + instance.IntegerArray(new int[0]); + return default(global::System.Threading.Tasks.ValueTask); + } case 1: { - instance.IntegerArray(global::TUnit.Core.Helpers.CastHelper.Cast(args[0])); + instance.IntegerArray((args[0] is null ? null : args[0] is int[] arr ? arr : new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]) })); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]) }); + return default(global::System.Threading.Tasks.ValueTask); + } + case 3: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]) }); + return default(global::System.Threading.Tasks.ValueTask); + } + case 4: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]) }); + return default(global::System.Threading.Tasks.ValueTask); + } + case 5: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]) }); + return default(global::System.Threading.Tasks.ValueTask); + } + case 6: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast(args[5]) }); return default(global::System.Threading.Tasks.ValueTask); } default: - throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + instance.IntegerArray((args.Length > 0 ? global::System.Linq.Enumerable.Range(0, args.Length).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new int[0])); + return default(global::System.Threading.Tasks.ValueTask); } } catch (global::System.Exception ex) diff --git a/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.MethodDataSource_WithConflictingNamespace.DotNet10_0.verified.txt b/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.MethodDataSource_WithConflictingNamespace.DotNet10_0.verified.txt index 17e51d2fa4..6033af57e1 100644 --- a/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.MethodDataSource_WithConflictingNamespace.DotNet10_0.verified.txt +++ b/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.MethodDataSource_WithConflictingNamespace.DotNet10_0.verified.txt @@ -181,12 +181,36 @@ global::TUnit.Core.ParameterMetadataFactory.Create(typeof(string[]), "strings", { switch (args.Length) { + case 0: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[0])); + } case 1: { - return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]))); + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest((args[0] is null ? null : args[0] is string[] arr ? arr : new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]) }))); + } + case 2: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]) })); + } + case 3: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]) })); + } + case 4: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]) })); + } + case 5: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]) })); + } + case 6: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast(args[5]) })); } default: - throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest((args.Length > 0 ? global::System.Linq.Enumerable.Range(0, args.Length).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new string[0]))); } } catch (global::System.Exception ex) diff --git a/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.MethodDataSource_WithConflictingNamespace.DotNet8_0.verified.txt b/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.MethodDataSource_WithConflictingNamespace.DotNet8_0.verified.txt index 17e51d2fa4..6033af57e1 100644 --- a/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.MethodDataSource_WithConflictingNamespace.DotNet8_0.verified.txt +++ b/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.MethodDataSource_WithConflictingNamespace.DotNet8_0.verified.txt @@ -181,12 +181,36 @@ global::TUnit.Core.ParameterMetadataFactory.Create(typeof(string[]), "strings", { switch (args.Length) { + case 0: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[0])); + } case 1: { - return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]))); + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest((args[0] is null ? null : args[0] is string[] arr ? arr : new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]) }))); + } + case 2: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]) })); + } + case 3: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]) })); + } + case 4: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]) })); + } + case 5: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]) })); + } + case 6: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast(args[5]) })); } default: - throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest((args.Length > 0 ? global::System.Linq.Enumerable.Range(0, args.Length).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new string[0]))); } } catch (global::System.Exception ex) diff --git a/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.MethodDataSource_WithConflictingNamespace.DotNet9_0.verified.txt b/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.MethodDataSource_WithConflictingNamespace.DotNet9_0.verified.txt index 17e51d2fa4..6033af57e1 100644 --- a/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.MethodDataSource_WithConflictingNamespace.DotNet9_0.verified.txt +++ b/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.MethodDataSource_WithConflictingNamespace.DotNet9_0.verified.txt @@ -181,12 +181,36 @@ global::TUnit.Core.ParameterMetadataFactory.Create(typeof(string[]), "strings", { switch (args.Length) { + case 0: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[0])); + } case 1: { - return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]))); + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest((args[0] is null ? null : args[0] is string[] arr ? arr : new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]) }))); + } + case 2: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]) })); + } + case 3: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]) })); + } + case 4: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]) })); + } + case 5: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]) })); + } + case 6: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast(args[5]) })); } default: - throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest((args.Length > 0 ? global::System.Linq.Enumerable.Range(0, args.Length).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new string[0]))); } } catch (global::System.Exception ex) diff --git a/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.MethodDataSource_WithConflictingNamespace.Net4_7.verified.txt b/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.MethodDataSource_WithConflictingNamespace.Net4_7.verified.txt index 2e2148a732..74e3dfcc0e 100644 --- a/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.MethodDataSource_WithConflictingNamespace.Net4_7.verified.txt +++ b/TUnit.Core.SourceGenerator.Tests/ConflictingNamespaceTests.MethodDataSource_WithConflictingNamespace.Net4_7.verified.txt @@ -181,12 +181,36 @@ global::TUnit.Core.ParameterMetadataFactory.Create(typeof(string[]), "strings", { switch (args.Length) { + case 0: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[0])); + } case 1: { - return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]))); + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest((args[0] is null ? null : args[0] is string[] arr ? arr : new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]) }))); + } + case 2: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]) })); + } + case 3: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]) })); + } + case 4: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]) })); + } + case 5: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]) })); + } + case 6: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast(args[5]) })); } default: - throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest((args.Length > 0 ? global::System.Linq.Enumerable.Range(0, args.Length).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new string[0]))); } } catch (global::System.Exception ex) diff --git a/TUnit.Core.SourceGenerator.Tests/DataDrivenTests.Test.verified.txt b/TUnit.Core.SourceGenerator.Tests/DataDrivenTests.Test.verified.txt index d755ba780c..99ac2392d3 100644 --- a/TUnit.Core.SourceGenerator.Tests/DataDrivenTests.Test.verified.txt +++ b/TUnit.Core.SourceGenerator.Tests/DataDrivenTests.Test.verified.txt @@ -1,4 +1,4 @@ -// +// #pragma warning disable #nullable enable @@ -234,13 +234,44 @@ global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "value", new glo { switch (args.Length) { + case 0: + { + instance.IntegerArray(new int[0]); + return default(global::System.Threading.Tasks.ValueTask); + } case 1: { - instance.IntegerArray(global::TUnit.Core.Helpers.CastHelper.Cast(args[0])); + instance.IntegerArray((args[0] is null ? null : args[0] is int[] arr ? arr : new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]) })); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]) }); + return default(global::System.Threading.Tasks.ValueTask); + } + case 3: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]) }); + return default(global::System.Threading.Tasks.ValueTask); + } + case 4: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]) }); + return default(global::System.Threading.Tasks.ValueTask); + } + case 5: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]) }); + return default(global::System.Threading.Tasks.ValueTask); + } + case 6: + { + instance.IntegerArray(new int[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast(args[5]) }); return default(global::System.Threading.Tasks.ValueTask); } default: - throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + instance.IntegerArray((args.Length > 0 ? global::System.Linq.Enumerable.Range(0, args.Length).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new int[0])); + return default(global::System.Threading.Tasks.ValueTask); } } catch (global::System.Exception ex) diff --git a/TUnit.Core.SourceGenerator.Tests/MethodDataSourceDrivenTests.Test.verified.txt b/TUnit.Core.SourceGenerator.Tests/MethodDataSourceDrivenTests.Test.verified.txt index 17e51d2fa4..74e3dfcc0e 100644 --- a/TUnit.Core.SourceGenerator.Tests/MethodDataSourceDrivenTests.Test.verified.txt +++ b/TUnit.Core.SourceGenerator.Tests/MethodDataSourceDrivenTests.Test.verified.txt @@ -1,4 +1,4 @@ -// +// #pragma warning disable #nullable enable @@ -181,12 +181,36 @@ global::TUnit.Core.ParameterMetadataFactory.Create(typeof(string[]), "strings", { switch (args.Length) { + case 0: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[0])); + } case 1: { - return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]))); + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest((args[0] is null ? null : args[0] is string[] arr ? arr : new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]) }))); + } + case 2: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]) })); + } + case 3: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]) })); + } + case 4: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]) })); + } + case 5: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]) })); + } + case 6: + { + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest(new string[] { global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast(args[5]) })); } default: - throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + return new global::System.Threading.Tasks.ValueTask(instance.EnumerableFuncArrayTest((args.Length > 0 ? global::System.Linq.Enumerable.Range(0, args.Length).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new string[0]))); } } catch (global::System.Exception ex) diff --git a/TUnit.Core.SourceGenerator.Tests/Tests2112.Test.verified.txt b/TUnit.Core.SourceGenerator.Tests/Tests2112.Test.verified.txt index 546d777591..7603da9ba8 100644 --- a/TUnit.Core.SourceGenerator.Tests/Tests2112.Test.verified.txt +++ b/TUnit.Core.SourceGenerator.Tests/Tests2112.Test.verified.txt @@ -79,7 +79,12 @@ global::TUnit.Core.ParameterMetadataFactory.Create(typeof(long[]), "arr", new gl return default(global::System.Threading.Tasks.ValueTask); } default: - throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + if (args.Length < 1) + { + throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}"); + } + instance.Test(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), (args.Length > 1 ? global::System.Linq.Enumerable.Range(1, args.Length - 1).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new long[0])); + return default(global::System.Threading.Tasks.ValueTask); } } catch (global::System.Exception ex) @@ -129,7 +134,12 @@ global::TUnit.Core.ParameterMetadataFactory.Create(typeof(long[]), "arr", new gl return default(global::System.Threading.Tasks.ValueTask); } default: - throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + if (args.Length < 1) + { + throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}"); + } + instance.Test2(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), (args.Length > 1 ? global::System.Linq.Enumerable.Range(1, args.Length - 1).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i])).ToArray() : new long[0])); + return default(global::System.Threading.Tasks.ValueTask); } } catch (global::System.Exception ex) diff --git a/TUnit.Core.SourceGenerator/CodeGenerators/Helpers/TupleArgumentHelper.cs b/TUnit.Core.SourceGenerator/CodeGenerators/Helpers/TupleArgumentHelper.cs index ec78c7f4d3..53b3ecd87e 100644 --- a/TUnit.Core.SourceGenerator/CodeGenerators/Helpers/TupleArgumentHelper.cs +++ b/TUnit.Core.SourceGenerator/CodeGenerators/Helpers/TupleArgumentHelper.cs @@ -53,8 +53,10 @@ public static List GenerateArgumentAccessWithParams(IList 0 && parameters[parameters.Count - 1].IsParams; + // A trailing array parameter (params OR a plain `T[]`) collects remaining loose values + // into the array, letting `[Arguments(["a", "b"])]` map onto a single `string[]` + // parameter (issue #6120). + var hasParams = parameters.Count > 0 && parameters[parameters.Count - 1].CollectsTrailingArguments(); if (!hasParams) { @@ -107,14 +109,19 @@ public static List GenerateArgumentAccessWithParams(IList {regularParamCount} ? global::System.Linq.Enumerable.Range({regularParamCount}, {argCountExpression} - {regularParamCount}).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast<{elementType.GloballyQualified()}>({argumentsArrayName}[i])).ToArray() : new {elementType.GloballyQualified()}[0])"; + // Dynamic count - create array from remaining arguments. With no leading + // regular parameters the range spans the whole args array, so drop the + // redundant "- 0" offset for cleaner generated code. + var rangeCount = regularParamCount == 0 + ? argCountExpression + : $"{argCountExpression} - {regularParamCount}"; + var arrayInit = $"({argumentsArrayName}.Length > {regularParamCount} ? global::System.Linq.Enumerable.Range({regularParamCount}, {rangeCount}).Select(i => global::TUnit.Core.Helpers.CastHelper.Cast<{elementType.GloballyQualified()}>({argumentsArrayName}[i])).ToArray() : new {elementType.GloballyQualified()}[0])"; argumentExpressions.Add(arrayInit); } else @@ -159,4 +166,33 @@ public static List GenerateArgumentAccessWithParams(IList + /// Gets the element type for a trailing collecting parameter. Handles plain arrays as well as + /// C# 13 params collections whose target is an array-assignable generic interface + /// (IEnumerable<T>, IReadOnlyList<T>, etc.) — for those a generated + /// T[] satisfies the parameter. Returns null when no safe array construction applies. + /// + private static ITypeSymbol? GetTrailingElementType(ITypeSymbol parameterType) + { + if (parameterType is IArrayTypeSymbol array) + { + return array.ElementType; + } + + if (parameterType is INamedTypeSymbol { IsGenericType: true } named && + IsArrayAssignableCollectionInterface(named.OriginalDefinition.SpecialType)) + { + return named.TypeArguments[0]; + } + + return null; + } + + private static bool IsArrayAssignableCollectionInterface(SpecialType specialType) + => specialType is SpecialType.System_Collections_Generic_IEnumerable_T + or SpecialType.System_Collections_Generic_ICollection_T + or SpecialType.System_Collections_Generic_IList_T + or SpecialType.System_Collections_Generic_IReadOnlyCollection_T + or SpecialType.System_Collections_Generic_IReadOnlyList_T; } diff --git a/TUnit.Core.SourceGenerator/Extensions/TypeSymbolExtensions.cs b/TUnit.Core.SourceGenerator/Extensions/TypeSymbolExtensions.cs index 9151c0f2b0..6d62757393 100644 --- a/TUnit.Core.SourceGenerator/Extensions/TypeSymbolExtensions.cs +++ b/TUnit.Core.SourceGenerator/Extensions/TypeSymbolExtensions.cs @@ -4,6 +4,19 @@ namespace TUnit.Core.SourceGenerator.Extensions; internal static class TypeSymbolExtensions { + /// + /// Determines whether this parameter collects trailing argument values into an array — + /// either a params T[] parameter or a plain trailing T[] parameter. The + /// latter lets [Arguments(["a", "b"])] map onto a single array parameter (issue #6120). + /// + /// + /// This is a type-level check only — it does not verify that the parameter is actually the + /// last one. Callers are responsible for the positional constraint (i.e. only invoking this + /// on the final parameter), since a non-trailing array binds value-by-value, not collected. + /// + public static bool CollectsTrailingArguments(this IParameterSymbol parameter) + => parameter.IsParams || parameter.Type is IArrayTypeSymbol; + /// /// Determines if the type is a nullable value type (e.g., int?, bool?, MyEnum?) /// diff --git a/TUnit.Core.SourceGenerator/Generators/TestMetadataGenerator.cs b/TUnit.Core.SourceGenerator/Generators/TestMetadataGenerator.cs index 89e74e7ad3..3a3c5a42ec 100644 --- a/TUnit.Core.SourceGenerator/Generators/TestMetadataGenerator.cs +++ b/TUnit.Core.SourceGenerator/Generators/TestMetadataGenerator.cs @@ -2643,23 +2643,34 @@ private static void GenerateConcreteTestInvokerBody(CodeWriter writer, string me } else { - // Count required parameters (those without default values, excluding CancellationToken and params parameters) - var requiredParamCount = parametersFromArgs.Count(p => !p.HasExplicitDefaultValue && p is { IsOptional: false, IsParams: false }); + // A trailing array parameter (params OR a plain `T[]`) binds like a params array: + // it accepts any number of remaining arguments collected into the array (issue #6120). + var lastIndex = parametersFromArgs.Length - 1; + var hasParams = parametersFromArgs.Length > 0 && parametersFromArgs[lastIndex].CollectsTrailingArguments(); + + // Count required parameters (those without default values, excluding CancellationToken + // and the trailing array/params parameter, which may receive zero arguments). + var requiredParamCount = parametersFromArgs + .Where((p, index) => index != lastIndex || !hasParams) + .Count(p => !p.HasExplicitDefaultValue && p is { IsOptional: false, IsParams: false }); // Generate runtime logic to handle variable argument counts writer.AppendLine("switch (args.Length)"); writer.AppendLine("{"); writer.Indent(); - // Check if last parameter is params array - var hasParams = parametersFromArgs.Length > 0 && parametersFromArgs[parametersFromArgs.Length - 1].IsParams; - - // For params arrays, we need to handle any number of arguments >= required count - // Generate a reasonable number of cases plus a default that handles the rest - var casesToGenerate = hasParams ? 10 : parametersFromArgs.Length - requiredParamCount + 1; + // A trailing params/array parameter accepts any argument count >= the required minimum. + // Emit explicit switch cases up to `maxExtraTrailingArgs` beyond the declared parameters; + // the `default` arm binds larger counts dynamically (matching the reflection path). + // Fixed-arity methods only need one case per optional parameter. + // Both bounds in the loop guard are real: `casesToGenerate` caps total cases, while the + // `+ maxExtraTrailingArgs` term caps how far past the declared arity we enumerate. + const int maxParamsCases = 10; + const int maxExtraTrailingArgs = 5; + var casesToGenerate = hasParams ? maxParamsCases : parametersFromArgs.Length - requiredParamCount + 1; // Generate cases for each valid argument count - for (var i = 0; i < casesToGenerate && requiredParamCount + i <= parametersFromArgs.Length + 5; i++) + for (var i = 0; i < casesToGenerate && requiredParamCount + i <= parametersFromArgs.Length + maxExtraTrailingArgs; i++) { var argCount = requiredParamCount + i; writer.AppendLine($"case {argCount}:"); @@ -2689,6 +2700,31 @@ private static void GenerateConcreteTestInvokerBody(CodeWriter writer, string me { writer.AppendLine($"throw new global::System.ArgumentException($\"Expected exactly {parametersFromArgs.Length} argument{(parametersFromArgs.Length == 1 ? "" : "s")}, but got {{args.Length}}\");"); } + else if (hasParams) + { + // A trailing array/params parameter accepts any number of trailing values, so there + // is no fixed upper bound — only a minimum (the required, non-collecting parameters). + // Counts beyond the statically-generated cases are bound dynamically so behaviour + // matches the reflection path (which has no such cap) — see issue #6120. + if (requiredParamCount > 0) + { + writer.AppendLine($"if (args.Length < {requiredParamCount})"); + writer.AppendLine("{"); + writer.Indent(); + writer.AppendLine($"throw new global::System.ArgumentException($\"Expected at least {requiredParamCount} argument{(requiredParamCount == 1 ? "" : "s")}, but got {{args.Length}}\");"); + writer.Unindent(); + writer.AppendLine("}"); + } + + var dynamicArgs = TupleArgumentHelper.GenerateArgumentAccessWithParams(parametersFromArgs, "args", "args.Length"); + if (hasCancellationToken) + { + dynamicArgs.Add("context?.Execution.CancellationToken ?? global::System.Threading.CancellationToken.None"); + } + + var dynamicMethodCall = $"instance.{methodName}({string.Join(", ", dynamicArgs)})"; + GenerateReturnHandling(writer, dynamicMethodCall, returnPattern); + } else { writer.AppendLine($"throw new global::System.ArgumentException($\"Expected between {requiredParamCount} and {parametersFromArgs.Length} arguments, but got {{args.Length}}\");"); @@ -3671,10 +3707,17 @@ private static void GenerateReturnHandling( break; case TestReturnPattern.Unknown: - // F# Async, custom awaitables - writer.AppendLine($"var methodResult = {methodCall};"); - writer.AppendLine("if (methodResult == null) return default(global::System.Threading.Tasks.ValueTask);"); - writer.AppendLine("return global::TUnit.Core.AsyncConvert.ConvertObject(methodResult);"); + // F# Async, custom awaitables. + // Wrap in its own block so the temporary local can never collide with a + // sibling/enclosing declaration when multiple invocations are emitted into + // the same scope (e.g. the array-argument binding paths). See #6122. + writer.AppendLine("{"); + writer.Indent(); + writer.AppendLine($"var __tunit_methodResult = {methodCall};"); + writer.AppendLine("if (__tunit_methodResult == null) return default(global::System.Threading.Tasks.ValueTask);"); + writer.AppendLine("return global::TUnit.Core.AsyncConvert.ConvertObject(__tunit_methodResult);"); + writer.Unindent(); + writer.AppendLine("}"); break; } } diff --git a/TUnit.Core/Attributes/TestData/ArgumentsAttribute.cs b/TUnit.Core/Attributes/TestData/ArgumentsAttribute.cs index ca1ad191ce..bce2979eb6 100644 --- a/TUnit.Core/Attributes/TestData/ArgumentsAttribute.cs +++ b/TUnit.Core/Attributes/TestData/ArgumentsAttribute.cs @@ -17,6 +17,13 @@ namespace TUnit.Core; /// Multiple ArgumentsAttribute instances can be applied to a single test method to create /// multiple test cases with different input values. /// +/// +/// A test method parameter that is an array (e.g. string[] names) collects the supplied +/// values into that array, so [Arguments("Skipper", "Lucy")] (or the equivalent collection +/// expression [Arguments(["Skipper", "Lucy"])]) maps onto a single string[] parameter. +/// For an unambiguous, strongly-typed array argument, prefer the generic form +/// [Arguments<string[]>(["Skipper", "Lucy"])]. +/// /// /// /// [Test] diff --git a/TUnit.Engine/Discovery/ReflectionTestDataCollector.cs b/TUnit.Engine/Discovery/ReflectionTestDataCollector.cs index cb184a3eee..4270a16ede 100644 --- a/TUnit.Engine/Discovery/ReflectionTestDataCollector.cs +++ b/TUnit.Engine/Discovery/ReflectionTestDataCollector.cs @@ -1661,6 +1661,40 @@ private static void InferGenericTypeMapping(Type paramType, [DynamicallyAccessed /// /// Checks if the argument type is compatible with the parameter type through covariance /// + // Mirrors the source generator's GetTrailingElementType: the element type for a trailing + // collecting parameter — a plain array, or a C# 13 params collection whose target is an + // array-assignable generic interface (a generated T[] satisfies the parameter). + private static Type? GetTrailingElementType(ParameterInfo parameter) + { + var type = parameter.ParameterType; + + if (type.IsArray) + { + return type.GetElementType(); + } + + if (type.IsGenericType) + { + var definition = type.GetGenericTypeDefinition(); + if (definition == typeof(IEnumerable<>) + || definition == typeof(ICollection<>) + || definition == typeof(IList<>) + || definition == typeof(IReadOnlyCollection<>) + || definition == typeof(IReadOnlyList<>)) + { + return type.GetGenericArguments()[0]; + } + } + + return null; + } + + // C# 13 params collections are marked with ParamCollectionAttribute rather than + // ParamArrayAttribute. Match by name so it works across target frameworks that predate the type. + private static bool IsParamCollection(ParameterInfo parameter) + => parameter.GetCustomAttributesData() + .Any(a => a.AttributeType.FullName == "System.Runtime.CompilerServices.ParamCollectionAttribute"); + private static bool IsCovariantCompatible(Type paramType, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)] Type argType) { // Only check for generic interface covariance @@ -1805,14 +1839,22 @@ private static bool MatchesCovariantInterface(Type paramType, Type paramGenericD var parameters = staticParameters ?? methodToInvoke.GetParameters(); var castedArgs = new object?[parameters.Length]; - // Check if the last parameter is a params array + // Check if the last parameter is a params array, or a plain trailing array + // parameter (e.g. `string[] names`). Both collect remaining loose arguments + // into the array, letting `[Arguments(["a", "b"])]` map onto a single array + // parameter (issue #6120). var lastParam = parameters.Length > 0 ? parameters[^1] : null; - var isParamsArray = lastParam != null && lastParam.IsDefined(typeof(ParamArrayAttribute), false); + var paramsElementType = lastParam != null ? GetTrailingElementType(lastParam) : null; + // A plain trailing array always collects (matches source-gen). A non-array collection + // only collects when it is a params collection (C# 13, ParamCollectionAttribute). + var isParamsArray = lastParam != null && paramsElementType != null + && (lastParam.ParameterType.IsArray + || lastParam.IsDefined(typeof(ParamArrayAttribute), false) + || IsParamCollection(lastParam)); if (isParamsArray && lastParam != null) { - // Handle params array parameter - var paramsElementType = lastParam.ParameterType.GetElementType(); + // Handle params array / params collection parameter var regularParamsCount = parameters.Length - 1; // Process regular parameters first diff --git a/TUnit.TestProject/ArgsAsArrayTests.cs b/TUnit.TestProject/ArgsAsArrayTests.cs index 71977529c9..97e8e30e4b 100644 --- a/TUnit.TestProject/ArgsAsArrayTests.cs +++ b/TUnit.TestProject/ArgsAsArrayTests.cs @@ -31,4 +31,54 @@ public void Following_Non_Params(int i, params IEnumerable arguments) Console.WriteLine(argument); } } + + // Issue #6120: a plain (non-params) array parameter collects loose argument values, + // so `[Arguments(["a", "b"])]` (a collection expression, identical to `[Arguments("a", "b")]`) + // maps onto a single `string[]` parameter. + [Test] + [Arguments(["Chloe"])] + [Arguments(["Skipper", "Lucy"])] + public async Task NonParamsStringArray(string[] names) + { + await Assert.That(names).IsNotEmpty(); + await Assert.That(names.All(n => !string.IsNullOrEmpty(n))).IsTrue(); + } + + [Test] + [Arguments("Chloe")] + public async Task NonParamsStringArray_SingleValue(string[] names) + { + await Assert.That(names).IsEquivalentTo(["Chloe"]); + } + + [Test] + [Arguments(["Skipper", "Lucy"])] + public async Task NonParamsStringArray_MultipleValues(string[] names) + { + await Assert.That(names).IsEquivalentTo(["Skipper", "Lucy"]); + } + + [Test] + [Arguments(1, 2, 3)] + public async Task NonParamsIntArray(int[] numbers) + { + await Assert.That(numbers).IsEquivalentTo([1, 2, 3]); + } + + // The strongly-typed generic form is the unambiguous way to pass an array as a single value. + [Test] + [Arguments(["Skipper", "Lucy"])] + public async Task GenericStringArray(string[] names) + { + await Assert.That(names).IsEquivalentTo(["Skipper", "Lucy"]); + } + + // Issue #6120: more loose values than the source generator emits static switch cases for + // (cap is parameterCount + 5) must still bind, matching the unbounded reflection path. + [Test] + [Arguments("a", "b", "c", "d", "e", "f", "g", "h")] + public async Task NonParamsStringArray_BeyondStaticCaseCap(string[] names) + { + await Assert.That(names).IsEquivalentTo(["a", "b", "c", "d", "e", "f", "g", "h"]); + } }