diff --git a/.claude/docs/project-structure.md b/.claude/docs/project-structure.md index c656a981782..67f835362da 100644 --- a/.claude/docs/project-structure.md +++ b/.claude/docs/project-structure.md @@ -16,3 +16,18 @@ Product projects live in `src/`, tests in `tests/`, and benchmarks in `benchmark Source-generated and reflection metadata feed the same execution path. Roslyn compatibility projects (`*.Roslyn414`, `*.Roslyn44`, `*.Roslyn47`) link shared sources from their base project; account for those variants when changing generators or analyzers. Generators, analyzers, code fixers and build tasks run inside consumers' compilers, so their behaviour must not depend on the build machine's culture (sv-SE renders negative numbers with U+2212, de-DE uses decimal commas, tr-TR lowercases `I` to `ı`). `Directory.Build.targets` applies `TUNITINT001` and `eng/BuildTimeGlobalization.globalconfig` (CA1304/CA1305/CA1309/CA1310/CA1311 as errors) to those projects; format and parse with `CultureInfo.InvariantCulture` and compare strings with `StringComparison.Ordinal`. `TUNITINT001` cannot see a number that is already typed `object` or an unconstrained generic before it is formatted (other than Roslyn's `TypedConstant.Value`); convert such values with `ToInvariantString()` or `Convert.ToString(value, CultureInfo.InvariantCulture)`. For a justified exception, such as text that is meant to follow the user's culture, wrap the line in `#pragma warning disable TUNITINT001` / `restore` with a comment explaining why; a false positive caused by a Roslyn or SDK change can be downgraded with `dotnet_diagnostic.TUNITINT001.severity` in `eng/BuildTimeGlobalization.globalconfig`. + +## Tuple method-type inference + +The generator uses Roslyn symbols and cannot share the runtime matcher. Keep these policies aligned; `Issue7629Tests` runs the shared `_7629/TupleInferenceTests.cs` fixtures in reflection and Native AOT (source-generated) modes in CI. `TupleInferenceTests` also snapshots generated metadata and invocation. + +| Rule | Generator | Runtime | +| --- | --- | --- | +| Whole tuple rows with omitted trailing parameters require invariant structure and consistent repeated bindings | `MatchesOpenRowType` without reconstruction | `TupleHelper.MatchesOpenTuple` / `MatchesType` | +| A sole tuple argument is reconstructed; closed elements may convert at invocation | `MatchesOpenRowType` tuple-element loop | `TestGenericTypeResolver.TryInferTypeMapping` tuple-element loop; invocation uses the same matcher | +| Reconstructed elements with no structural match defer casts to invocation and supply no bindings | `MatchesOpenRowType` with overwrite bindings | `TryInferTypeMapping` with overwrite bindings | +| Structural open elements (direct, nullable, array, matching generic) use the last repeated binding | `MatchesOpenRowType` with overwrite bindings | `TryInferTypeMapping` with overwrite bindings | +| Interface/base candidates retain tuple context but isolate bindings, reject conflicting repeated bindings through nested tuple arguments, and validate closed type arguments | `MatchesOpenRowType` candidate copies and completed-type conversion check | `TryInferTypeMapping` candidate copies and completed-type assignability | +| Ordinary spread columns retain ordinary inference, including matching-family tuple columns | `ProcessTypeForGenerics` | `TryInferTypeMapping` without tuple-element reconstruction; `ReflectionTestDataCollector.InferGenericTypeMapping` | + +`ReflectionTestDataCollector` delegates reconstructed tuple inference to `TryInferTypeMapping`; its ordinary-parameter inference remains separate. Unmatched open elements (including object, interface, and base declarations) likewise require other elements to infer the method types before invocation can cast them. Closed reconstructed elements may fail during invocation if their runtime values cannot convert; inference intentionally does not reject them from their declared types alone. Nullable stripping in the generator tuple loop handles direct type-parameter binding; recursive calls receive the original elements so structural nullable handling remains intact. diff --git a/src/TUnit.Core.SourceGenerator/Generators/TestMetadataGenerator.cs b/src/TUnit.Core.SourceGenerator/Generators/TestMetadataGenerator.cs index 9d4ec66e233..714d89b4d98 100644 --- a/src/TUnit.Core.SourceGenerator/Generators/TestMetadataGenerator.cs +++ b/src/TUnit.Core.SourceGenerator/Generators/TestMetadataGenerator.cs @@ -7288,7 +7288,7 @@ private static IEnumerable GetOwnClassMethodDataSourcesForInstant return namedType.TupleElements.Select(element => element.Type).ToArray(); } - if (namedType is not { Name: "Tuple", Arity: >= 1 and <= 8, ContainingNamespace: { Name: "System", ContainingNamespace.IsGlobalNamespace: true } }) + if (namedType is not { Name: "Tuple" or "ValueTuple", Arity: >= 1 and <= 8, ContainingNamespace: { Name: "System", ContainingNamespace.IsGlobalNamespace: true } }) { return null; } @@ -7303,6 +7303,137 @@ private static IEnumerable GetOwnClassMethodDataSourcesForInstant : null; } + private static bool MatchesOpenRowType(ITypeSymbol parameter, ITypeSymbol row, Compilation compilation, + Dictionary bindings, bool reconstructTupleElements, bool overwriteBindings = false) + { + if (parameter is ITypeParameterSymbol) + { + // Structural tuple-element inference follows ProcessTypeForGenerics: later + // occurrences win. Interface/base candidates deliberately use strict bindings. + if (overwriteBindings) + { + bindings[parameter] = row; + return true; + } + if (bindings.TryGetValue(parameter, out var bound)) + return SymbolEqualityComparer.Default.Equals(bound, row); + bindings.Add(parameter, row); + return true; + } + // A sole tuple parameter is reconstructed element by element at invocation. + // Closed elements do not contribute to inference: their values may support runtime + // conversions that their declared types cannot prove (for example object boxing int). + // Whole rows and interface/base candidates retain exact closed-argument matching. + // overwriteBindings marks structural element inference, not candidate validation. + if (!CodeGenerationHelpers.ContainsTypeParameter(parameter)) + { + return (reconstructTupleElements && overwriteBindings) || SymbolEqualityComparer.Default.Equals(parameter, row); + } + + // Tuple reconstruction can lift a non-nullable value into an open nullable element, + // just as ProcessTypeForGenerics and reflection TryInferTypeMapping do during inference. + if (reconstructTupleElements + && parameter is INamedTypeSymbol { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T } nullableParameter + && row.IsValueType + && row is not INamedTypeSymbol { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T }) + { + return MatchesOpenRowType(nullableParameter.TypeArguments[0], row, compilation, bindings, true, overwriteBindings); + } + + // A single tuple argument is reconstructed by the generated binder, including across + // Tuple and ValueTuple families. Multi-parameter rows require an exact constructed shape, + // matching TupleHelper.MatchesOpenTuple, since their binder uses whole-type assignability. + if (reconstructTupleElements && GetTupleElementTypes(parameter) is { } parameterElements + && GetTupleElementTypes(row) is { } rowElements && parameterElements.Length == rowElements.Length) + { + for (var i = 0; i < parameterElements.Length; i++) + { + // Sole tuple arguments are rebuilt with per-element conversions. Preserve + // the existing last-element inference through structurally matching elements; + // nested interface/base candidates still require consistent bindings. + var parameterElement = parameterElements[i]; + var rowElement = rowElements[i]; + if (parameterElement is INamedTypeSymbol + { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T } nullableElement + && rowElement.IsValueType) + { + parameterElement = nullableElement.TypeArguments[0]; + if (rowElement is INamedTypeSymbol + { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T } nullableRowElement) + rowElement = nullableRowElement.TypeArguments[0]; + } + if (parameterElement is ITypeParameterSymbol) + { + if (!MatchesOpenRowType(parameterElement, rowElement, compilation, bindings, true, overwriteBindings)) return false; + continue; + } + if (!MatchesOpenRowType(parameterElements[i], rowElements[i], compilation, bindings, true, overwriteBindings)) return false; + } + return true; + } + + if (parameter is IArrayTypeSymbol array + && row is IArrayTypeSymbol rowArray && array.Rank == rowArray.Rank) + { + return MatchesOpenRowType(array.ElementType, rowArray.ElementType, compilation, bindings, reconstructTupleElements, overwriteBindings); + } + + if (parameter is INamedTypeSymbol { IsGenericType: true } named + && row is INamedTypeSymbol { IsGenericType: true } rowNamed + && SymbolEqualityComparer.Default.Equals(named.OriginalDefinition, rowNamed.OriginalDefinition)) + { + var validateCandidate = reconstructTupleElements && !overwriteBindings; + for (var i = 0; i < named.TypeArguments.Length; i++) + { + // Infer the open arguments first. Closed arguments are checked on the completed + // candidate below, where interface variance has its correct direction and scope. + if (validateCandidate && !CodeGenerationHelpers.ContainsTypeParameter(named.TypeArguments[i])) continue; + if (!MatchesOpenRowType(named.TypeArguments[i], rowNamed.TypeArguments[i], compilation, bindings, reconstructTupleElements, overwriteBindings)) return false; + } + if (validateCandidate) + { + var typeParameters = bindings.Keys.Cast().ToImmutableArray(); + var typeArguments = typeParameters.Select(typeParameter => bindings[typeParameter]).ToArray(); + var completedParameter = SubstituteTypeParameters(parameter, typeParameters, typeArguments, compilation); + return SatisfiesTypeConstraint(row, completedParameter, compilation); + } + return true; + } + + // The binder also supports converting a derived element to a generic base class. + // Only reconstruction permits this conversion; whole multi-parameter rows stay invariant. + if (reconstructTupleElements && parameter is INamedTypeSymbol { IsGenericType: true, TypeKind: TypeKind.Class } classParameter) + { + for (var baseType = row.BaseType; baseType is not null; baseType = baseType.BaseType) + { + if (!SymbolEqualityComparer.Default.Equals(classParameter.OriginalDefinition, baseType.OriginalDefinition)) continue; + var candidateBindings = new Dictionary(bindings, SymbolEqualityComparer.Default); + if (!MatchesOpenRowType(parameter, baseType, compilation, candidateBindings, true)) continue; + foreach (var binding in candidateBindings) bindings[binding.Key] = binding.Value; + return true; + } + } + + // Reconstructed tuple elements may bind a concrete collection to an open interface. + // Keep candidate bindings isolated so a rejected interface cannot affect another match. + if (reconstructTupleElements && parameter is INamedTypeSymbol { IsGenericType: true, TypeKind: TypeKind.Interface } interfaceParameter) + { + foreach (var implementedInterface in row.AllInterfaces) + { + if (!SymbolEqualityComparer.Default.Equals(interfaceParameter.OriginalDefinition, implementedInterface.OriginalDefinition)) continue; + var candidateBindings = new Dictionary(bindings, SymbolEqualityComparer.Default); + if (!MatchesOpenRowType(parameter, implementedInterface, compilation, candidateBindings, true)) continue; + foreach (var binding in candidateBindings) bindings[binding.Key] = binding.Value; + return true; + } + } + + // An unmatched reconstructed element supplies no structural bindings. Its declared + // interface/base type may hide a compatible runtime value; let the binder cast it. + // Candidate validation remains strict because it never overwrites bindings. + return reconstructTupleElements && overwriteBindings; + } + private static ITypeSymbol[]? InferTypesFromMethodDataSourceRowType(TestMethodMetadata testMethod, AttributeData mdsAttr, ITypeSymbol[]? classTypes = null) { if (mdsAttr.ConstructorArguments.Length == 0) @@ -7346,14 +7477,38 @@ ITypeSymbol CloseClassType(ITypeSymbol type) => classTypes is null || classTypes var genericParams = testMethod.MethodSymbol.TypeParameters; var genericParamMap = new Dictionary(); - if (rowType is INamedTypeSymbol { IsTupleType: true } tupleType - && !(testMethodParams.Length == 1 && testMethodParams[0].Type.IsTupleType)) + // A typed tuple parameter receives the whole row when the remaining parameters can be + // omitted (optional or a trailing collection). A bare type parameter normally + // receives the first element, as reflection mode unwraps tuple rows before inference. + // With explicit method types, preserve whole reference-tuple inference so it deduplicates + // against GenerateGenericTest> instead of adding a first-element instantiation. + Dictionary? wholeTupleBindings = null; + var receivesWholeTuple = testMethodParams.Length > 0 + && ((GetTupleElementTypes(CloseClassType(testMethodParams[0].Type)) is not null + && testMethodParams.Skip(1).All(parameter => parameter.IsOptional || parameter.IsParams + || SymbolEqualityComparer.Default.Equals(parameter, testMethodParams[^1]) && parameter.CollectsTrailingArguments()) + && MatchesOpenRowType(CloseClassType(testMethodParams[0].Type), rowType, compilation, + wholeTupleBindings = new Dictionary(SymbolEqualityComparer.Default), + reconstructTupleElements: testMethodParams.Length == 1, overwriteBindings: testMethodParams.Length == 1)) + || (testMethodParams.Length == 1 + && testMethodParams[0].Type is ITypeParameterSymbol + && rowType is INamedTypeSymbol { IsTupleType: false } + && testMethod.MethodAttributes.Any(static attribute => attribute.AttributeClass?.IsOrInherits("global::TUnit.Core.GenerateGenericTestAttribute") is true))); + + if (GetTupleElementTypes(rowType) is { } tupleElements && !receivesWholeTuple) { // A tuple row is spread across the test method's parameters - var tupleElements = tupleType.TupleElements; for (var i = 0; i < testMethodParams.Length && i < tupleElements.Length; i++) { - ProcessTypeForGenerics(CloseClassType(testMethodParams[i].Type), tupleElements[i].Type, genericParams, genericParamMap); + ProcessTypeForGenerics(CloseClassType(testMethodParams[i].Type), tupleElements[i], genericParams, genericParamMap); + } + } + else if (receivesWholeTuple && wholeTupleBindings is { Count: > 0 }) + { + foreach (var binding in wholeTupleBindings) + { + if (binding.Key is ITypeParameterSymbol parameter && genericParams.Contains(parameter)) + genericParamMap[parameter.Name] = binding.Value; } } else if (testMethodParams.Length > 0) diff --git a/src/TUnit.Core/Helpers/DataSourceHelpers.cs b/src/TUnit.Core/Helpers/DataSourceHelpers.cs index 55ab4c99077..8354f7e71b6 100644 --- a/src/TUnit.Core/Helpers/DataSourceHelpers.cs +++ b/src/TUnit.Core/Helpers/DataSourceHelpers.cs @@ -535,7 +535,9 @@ public static T InvokeIfFunc(object? value) // Keep a matching first tuple parameter whole, including when later parameters // are omitted. A nested row of a different type still spreads into columns. if (TupleHelper.IsTupleType(expectedTypes[0]) - && (expectedTypes.Length == 1 || expectedTypes[0].IsInstanceOfType(item))) + && (expectedTypes.Length == 1 || expectedTypes[0].ContainsGenericParameters + && TupleHelper.MatchesOpenTuple(expectedTypes[0], item.GetType()) + || expectedTypes[0].IsInstanceOfType(item))) { if (RequiresFlattenedTupleBinding(item)) { diff --git a/src/TUnit.Core/Helpers/TestDataRowUnwrapper.cs b/src/TUnit.Core/Helpers/TestDataRowUnwrapper.cs index b36a14477c0..66b93386016 100644 --- a/src/TUnit.Core/Helpers/TestDataRowUnwrapper.cs +++ b/src/TUnit.Core/Helpers/TestDataRowUnwrapper.cs @@ -63,9 +63,10 @@ public static bool IsTestDataRowType(Type? type) /// Unwraps an array of values, extracting TestDataRow metadata from single-element arrays. /// /// The array of values to unwrap. - /// Preserve tuple payloads assignable to this parameter type. + /// Preserve tuple payloads assignable to, or matching, this open tuple parameter type. + /// Preserve any tuple payload for a sole tuple parameter, whose elements are reconstructed at invocation. /// A tuple of the unwrapped data array and any extracted metadata. - public static (object?[] Data, TestDataRowMetadata? Metadata) UnwrapArray(object?[] values, Type? expectedTupleType = null) + public static (object?[] Data, TestDataRowMetadata? Metadata) UnwrapArray(object?[] values, Type? expectedTupleType = null, bool reconstructTuple = false) { if (values.Length == 1 && TryUnwrap(values[0], out var data, out var metadata)) { @@ -83,7 +84,11 @@ public static (object?[] Data, TestDataRowMetadata? Metadata) UnwrapArray(object } // Check if the data is a tuple that should be expanded - if (DataSourceHelpers.IsTuple(data) && (expectedTupleType is null || !expectedTupleType.IsInstanceOfType(data))) + if (DataSourceHelpers.IsTuple(data) + && !(expectedTupleType is not null + && (reconstructTuple || expectedTupleType.IsInstanceOfType(data) + || expectedTupleType.ContainsGenericParameters + && TupleHelper.MatchesOpenTuple(expectedTupleType, data!.GetType())))) { return (data.ToObjectArray(), metadata); } diff --git a/src/TUnit.Core/Helpers/TupleHelper.cs b/src/TUnit.Core/Helpers/TupleHelper.cs index 3e6dc49bfb3..b7fc7a0f50c 100644 --- a/src/TUnit.Core/Helpers/TupleHelper.cs +++ b/src/TUnit.Core/Helpers/TupleHelper.cs @@ -11,6 +11,52 @@ namespace TUnit.Core.Helpers; public static class TupleHelper { + // Process-lifetime cache: one entry per distinct parameter/source type pair. + private static readonly ConcurrentDictionary<(Type Parameter, Type Row), bool> OpenTupleMatches = new(); + + // Open tuple types cannot use IsInstanceOfType. Match their complete shape so a nested + // row with separate columns is not mistaken for the first tuple argument. + internal static bool MatchesOpenTuple(Type parameter, Type row) => + OpenTupleMatches.GetOrAdd((parameter, row), static pair => MatchesType(pair.Parameter, pair.Row, new Dictionary())); + + private static bool MatchesType(Type parameter, Type row, Dictionary bindings) + { + if (parameter.IsGenericParameter) + { + if (bindings.TryGetValue(parameter, out var bound)) return bound == row; + bindings.Add(parameter, row); + return true; + } + + if (!parameter.ContainsGenericParameters) + { + // Tuple type arguments are invariant. Element assignability alone does not make + // the constructed outer tuple assignable. Mirrors generator MatchesOpenRowType. + return parameter == row; + } + + if (parameter.IsArray) + { + return row.IsArray && parameter.GetArrayRank() == row.GetArrayRank() + && MatchesType(parameter.GetElementType()!, row.GetElementType()!, bindings); + } + + if (!parameter.IsGenericType || !row.IsGenericType + || parameter.GetGenericTypeDefinition() != row.GetGenericTypeDefinition()) + { + return false; + } + + var parameters = parameter.GetGenericArguments(); + var arguments = row.GetGenericArguments(); + for (var i = 0; i < parameters.Length; i++) + { + if (!MatchesType(parameters[i], arguments[i], bindings)) return false; + } + + return true; + } + #if NET /// /// Checks if a type is a tuple type (ValueTuple or Tuple) diff --git a/src/TUnit.Engine/Discovery/ReflectionTestDataCollector.cs b/src/TUnit.Engine/Discovery/ReflectionTestDataCollector.cs index 3f9eda280d5..74be3b3b220 100644 --- a/src/TUnit.Engine/Discovery/ReflectionTestDataCollector.cs +++ b/src/TUnit.Engine/Discovery/ReflectionTestDataCollector.cs @@ -11,6 +11,7 @@ using System.Runtime.ExceptionServices; using Microsoft.Testing.Platform.Requests; using TUnit.Core; +using TUnit.Core.Exceptions; using TUnit.Core.Helpers; using TUnit.Engine.Building; using TUnit.Engine.Building.Interfaces; @@ -2919,8 +2920,9 @@ private static bool IsSingleDimensionalZeroBasedArray(Type type) /// constructor argument is the member name ([MethodDataSource("Rows")] and /// [MethodDataSource<T>("Rows")]), looks for a static parameterless method of that name /// declared on the test class (or on T), and requires its declared return type to be - /// IEnumerable<Func<(...)>>. Each tuple element is matched against the data parameter - /// at the same position, including type arguments nested in generic parameter types. The caller passes + /// IEnumerable<TRow>, unwrapping one outer Func and one TestDataRow with its optional inner Func. + /// Each tuple element is matched + /// against the data parameter at the same position, including type arguments nested in generic parameter types. The caller passes /// the parameters without any CancellationToken, as the generator's GetDataParameters does. /// [UnconditionalSuppressMessage("Trimming", "IL2070", Justification = "Reflection mode requires dynamic access to data source methods")] @@ -2949,18 +2951,57 @@ private static bool IsSingleDimensionalZeroBasedArray(Type type) modifiers: null); if (dataMethod?.ReturnType is not { IsGenericType: true } returnType - || returnType.GetGenericTypeDefinition() != typeof(IEnumerable<>) - || returnType.GetGenericArguments()[0] is not { IsGenericType: true } funcType - || funcType.GetGenericTypeDefinition() != typeof(Func<>) - || GetValueTupleElementTypes(funcType.GetGenericArguments()[0]) is not { } tupleElements) + || returnType.GetGenericTypeDefinition() != typeof(IEnumerable<>)) + { + return null; + } + + var rowType = UnwrapFunc(returnType.GetGenericArguments()[0]); + if (FindTestDataRowType(rowType) is { } testDataRowType) + { + rowType = UnwrapFunc(testDataRowType.GetGenericArguments()[0]); + } + + if (GetTupleElementTypes(rowType) is not { } tupleElements) { return null; } var typeArguments = new Type?[genericParameterCount]; - for (var i = 0; i < parameters.Length && i < tupleElements.Length; i++) + // This path supplements explicit method types. Like the generator, a sole bare T + // receives a reference tuple whole, so the inferred and explicit tuple types deduplicate. + var receivesWholeTuple = parameters.Length > 0 + && ((GetTupleElementTypes(parameters[0].ParameterType) is not null + && parameters.Skip(1).All(parameter => parameter.IsOptional + || parameter.IsDefined(typeof(ParamArrayAttribute), false) + || IsParamCollection(parameter) + || (parameter == parameters[^1] && IsSingleDimensionalZeroBasedArray(parameter.ParameterType))) + && (parameters.Length == 1 || TupleHelper.MatchesOpenTuple(parameters[0].ParameterType, rowType))) + || (parameters.Length == 1 && parameters[0].ParameterType.IsGenericParameter && !rowType.IsValueType)); + + if (receivesWholeTuple) + { + // Match the same whole row as generated discovery. Sole tuples reconstruct their + // elements; tuples with omitted trailing parameters retain strict whole-row bindings. + var bindings = new Dictionary(); + if (!TestGenericTypeResolver.TryInferTypeMapping(parameters[0].ParameterType, rowType, bindings, + tupleElement: parameters.Length == 1, overwriteBindings: parameters.Length == 1)) + { + return null; + } + + foreach (var binding in bindings) + { + if (binding.Key.IsGenericParameter && binding.Key.DeclaringMethod is not null) + typeArguments[binding.Key.GenericParameterPosition] = binding.Value; + } + } + else { - MapGenericParameters(parameters[i].ParameterType, tupleElements[i], typeArguments); + for (var i = 0; i < parameters.Length && i < tupleElements.Length; i++) + { + MapGenericParameters(parameters[i].ParameterType, tupleElements[i], typeArguments); + } } foreach (var typeArgument in typeArguments) @@ -3128,6 +3169,22 @@ private static void MapGenericParameters(Type parameterType, Type actualType, Ty return; } + // Keep ordinary column inference aligned with ProcessTypeForGenerics, including + // later-column overwrites through nullable values and matching-rank arrays. + if (Nullable.GetUnderlyingType(parameterType) is { } nullableParameter + && actualType.IsValueType && Nullable.GetUnderlyingType(actualType) is null) + { + MapGenericParameters(nullableParameter, actualType, typeArguments); + return; + } + + if (parameterType.IsArray && actualType.IsArray + && parameterType.GetArrayRank() == actualType.GetArrayRank()) + { + MapGenericParameters(parameterType.GetElementType()!, actualType.GetElementType()!, typeArguments); + return; + } + if (parameterType.IsGenericType && actualType.IsGenericType && parameterType.GetGenericTypeDefinition() == actualType.GetGenericTypeDefinition()) @@ -3681,13 +3738,26 @@ public override Func /// Infers generic type mappings from parameter and argument types /// - private static void InferGenericTypeMapping(Type paramType, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)] Type argType, Dictionary typeMapping, bool isTopLevel = false) + private static void InferGenericTypeMapping(Type paramType, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)] Type argType, Dictionary typeMapping, bool isTopLevel = false, bool tupleElement = false) { + // Tuple reconstruction uses the same strict candidate selection as discovery. Ordinary + // parameters retain the existing nested/params-array inference policy below. + if (tupleElement) + { + if (!TestGenericTypeResolver.TryInferTypeMapping(paramType, argType, typeMapping, + tupleElement: true, overwriteBindings: isTopLevel)) + { + throw new GenericTypeResolutionException( + $"Type mismatch: Cannot use argument of type '{argType.Name}' for parameter of type '{paramType.Name}'"); + } + return; + } + // Match discovery inference when a nullable tuple element has been boxed as its value. if (Nullable.GetUnderlyingType(paramType) is { } underlyingParameter && argType.IsValueType && Nullable.GetUnderlyingType(argType) is null) { - InferGenericTypeMapping(underlyingParameter, argType, typeMapping, isTopLevel); + InferGenericTypeMapping(underlyingParameter, argType, typeMapping, isTopLevel, tupleElement); return; } @@ -3724,7 +3794,18 @@ private static void InferGenericTypeMapping(Type paramType, [DynamicallyAccessed for (var i = 0; i < paramGenArgs.Length && i < argGenArgs.Length; i++) { - InferGenericTypeMapping(paramGenArgs[i], argGenArgs[i], typeMapping); + var parameterElement = paramGenArgs[i]; + var argumentElement = argGenArgs[i]; + if (TupleHelper.IsTupleType(paramType) + && Nullable.GetUnderlyingType(parameterElement) is { } nullableElement + && argumentElement.IsValueType) + { + parameterElement = nullableElement; + argumentElement = Nullable.GetUnderlyingType(argumentElement) ?? argumentElement; + } + InferGenericTypeMapping(parameterElement, argumentElement, typeMapping, + isTopLevel: (tupleElement && isTopLevel) || TupleHelper.IsTupleType(paramType), + tupleElement: tupleElement || TupleHelper.IsTupleType(paramType)); } } else @@ -4027,6 +4108,9 @@ private static object ConstructInvocationTuple(Type tupleType, object?[] element ? Array.FindIndex(methodParams, static p => p.ParameterType != typeof(CancellationToken)) : 0; var inferenceCount = flattenedTupleTypes?.Length ?? methodParams.Length; + var reconstructTuple = flattenedTupleTypes is not null + || GetSingleDataParameter(methodParams) is { ParameterType: var soleType } + && TupleHelper.IsTupleType(soleType); // Build type mapping from method parameters (or flattened tuple elements) and actual arguments. for (var j = 0; j < inferenceCount && j + tupleOffset < args.Length; j++) @@ -4036,7 +4120,8 @@ private static object ConstructInvocationTuple(Type tupleType, object?[] element { var paramType = flattenedTupleTypes?[j] ?? methodParams[j].ParameterType; var argType = GetArgumentInferenceType(arg); - InferGenericTypeMapping(paramType, argType, typeMapping, isTopLevel: true); + InferGenericTypeMapping(paramType, argType, typeMapping, isTopLevel: true, + tupleElement: reconstructTuple); } } @@ -4115,7 +4200,7 @@ private static object ConstructInvocationTuple(Type tupleType, object?[] element var singleDataIndex = tupleElements is not null ? Array.FindIndex(parameters, static p => p.ParameterType != typeof(CancellationToken)) : -1; - // Singleton value-tuple rows stay wrapped through DataUnwrapper, including + // Singleton value-tuple rows stay wrapped through DataUnwrapper for either target family, including // incompatible containers whose elements need conversion. Match the generated // invoker instead of treating that container as an already-flattened element. // A retained TupleArgument is an inner element of a flattened row, so its @@ -4127,8 +4212,7 @@ private static object ConstructInvocationTuple(Type tupleType, object?[] element || args[singleDataIndex] is { } singleValue && !(DataSourceHelpers.IsTuple(singleValue) && DataSourceHelpers.UnwrapTupleAot(singleValue) is [null]) && !parameters[singleDataIndex].ParameterType.IsInstanceOfType(singleValue) - && !(parameters[singleDataIndex].ParameterType.IsValueType - && DataSourceHelpers.IsTuple(singleValue) && DataSourceHelpers.UnwrapTupleAot(singleValue).Length == 1))) + && !(DataSourceHelpers.IsTuple(singleValue) && DataSourceHelpers.UnwrapTupleAot(singleValue).Length == 1))) { // DataUnwrapper spreads an incompatible tuple so each element can be // converted before constructing the target, as the generated invoker does. diff --git a/src/TUnit.Engine/Helpers/DataUnwrapper.cs b/src/TUnit.Engine/Helpers/DataUnwrapper.cs index 9d7b3b2b041..7fec4afb5c0 100644 --- a/src/TUnit.Engine/Helpers/DataUnwrapper.cs +++ b/src/TUnit.Engine/Helpers/DataUnwrapper.cs @@ -48,8 +48,12 @@ public static (object?[] Data, TestDataRowMetadata? Metadata) UnwrapWithTypesAnd ParameterMetadata[]? expectedParameters) { // First check for TestDataRow wrapper + var reconstructTuple = false; + var tupleType = values is [ITestDataRow] + ? GetTupleDataParameterType(expectedParameters, out reconstructTuple) + : null; var (unwrapped, metadata) = TestDataRowUnwrapper.UnwrapArray(values, - values is [ITestDataRow] ? GetTupleDataParameterType(expectedParameters) : null); + tupleType, reconstructTuple); // Then apply type-aware unwrapping var data = UnwrapWithTypesInternal(unwrapped, expectedParameters); @@ -59,13 +63,18 @@ public static (object?[] Data, TestDataRowMetadata? Metadata) UnwrapWithTypesAnd public static object?[] UnwrapWithTypes(object?[] values, ParameterMetadata[]? expectedParameters) { // First handle TestDataRow unwrapping + var reconstructTuple = false; + var tupleType = values is [ITestDataRow] + ? GetTupleDataParameterType(expectedParameters, out reconstructTuple) + : null; var (unwrapped, _) = TestDataRowUnwrapper.UnwrapArray(values, - values is [ITestDataRow] ? GetTupleDataParameterType(expectedParameters) : null); + tupleType, reconstructTuple); return UnwrapWithTypesInternal(unwrapped, expectedParameters); } - private static Type? GetTupleDataParameterType(ParameterMetadata[]? parameters) + private static Type? GetTupleDataParameterType(ParameterMetadata[]? parameters, out bool reconstructTuple) { + reconstructTuple = false; if (parameters is null) { return null; @@ -79,6 +88,18 @@ public static (object?[] Data, TestDataRowMetadata? Metadata) UnwrapWithTypesAnd continue; } + // A sole tuple parameter reconstructs elements across tuple families. Preserve its + // payload boundary even when strict whole-row matching would reject it. + reconstructTuple = true; + for (var j = i + 1; j < parameters.Length; j++) + { + if (parameters[j].Type != typeof(CancellationToken)) + { + reconstructTuple = false; + break; + } + } + // Wrapped and unwrapped rows must use the same whole-tuple binding rule. return TupleHelper.IsTupleType(dataType) && RemainingDataParametersAreOmittable(parameters, i) ? dataType @@ -163,7 +184,20 @@ public static (object?[] Data, TestDataRowMetadata? Metadata) UnwrapWithTypesAnd // A reference tuple with a lone null must retain its container: [null] also // represents an actual null argument. Value tuples always reconstruct from null. var tupleElements = DataSourceHelpers.RetainTupleElements(values[0]); - return !lastDataParameterType.IsValueType && tupleElements is [null] ? values : tupleElements; + if (!lastDataParameterType.IsValueType && tupleElements is [null]) + { + return values; + } + + // A singleton tuple element is a flattened column, not a preserved whole row. + // Retain its boundary explicitly so invocation can reconstruct the outer tuple + // without guessing from the inner tuple's arity. + if (tupleElements is [var element] && element is not TupleArgument && DataSourceHelpers.IsTuple(element)) + { + tupleElements[0] = new TupleArgument(element!.GetType(), DataSourceHelpers.RetainTupleElements(element)); + } + + return tupleElements; } // A tuple that is already an instance of the first data parameter's tuple type binds to it @@ -171,7 +205,10 @@ public static (object?[] Data, TestDataRowMetadata? Metadata) UnwrapWithTypesAnd var firstDataParameterType = expectedParameters[firstDataParameterIndex].Type; if (dataParameterCount > 1 && TupleHelper.IsTupleType(firstDataParameterType) - && (firstDataParameterType.IsInstanceOfType(values[0]) + && (firstDataParameterType.ContainsGenericParameters + && values[0] is { } firstValue + && TupleHelper.MatchesOpenTuple(firstDataParameterType, firstValue.GetType()) + || firstDataParameterType.IsInstanceOfType(values[0]) || values[0] is TupleArgument argument && argument.TupleType == firstDataParameterType) && RemainingDataParametersAreOmittable(expectedParameters, firstDataParameterIndex)) { diff --git a/src/TUnit.Engine/Services/TestGenericTypeResolver.cs b/src/TUnit.Engine/Services/TestGenericTypeResolver.cs index 4604ba62b8f..7966fedbce1 100644 --- a/src/TUnit.Engine/Services/TestGenericTypeResolver.cs +++ b/src/TUnit.Engine/Services/TestGenericTypeResolver.cs @@ -489,7 +489,8 @@ private static Type[] ResolveMethodGenericArguments( else { // Try to infer nested generic types - InferTypeMapping(paramType, argType, typeMapping, genericMethodInfo.ParameterPositions); + InferTypeMapping(paramType, argType, typeMapping, genericMethodInfo.ParameterPositions, tupleElementTypes is not null + || dataParameterCount == 1 && TupleHelper.IsTupleType(paramType)); } } else if (paramType is { IsGenericParameter: true, DeclaringMethod: not null }) @@ -608,9 +609,9 @@ private static void InferTypeMapping( Type parameterType, Type argumentType, Dictionary typeMapping, - int[] genericParameterPositions) + int[] genericParameterPositions, bool tupleElement = false) { - if (!TryInferTypeMapping(parameterType, argumentType, typeMapping)) + if (!TryInferTypeMapping(parameterType, argumentType, typeMapping, tupleElement, tupleElement)) { throw new GenericTypeResolutionException( $"Type mismatch: Cannot use argument of type '{argumentType.Name}' for parameter of type '{parameterType.Name}'"); @@ -620,21 +621,27 @@ private static void InferTypeMapping( #if NET8_0_OR_GREATER [RequiresUnreferencedCode("Type mapping inference uses Type.GetInterfaces and reflection")] #endif - private static bool TryInferTypeMapping( + internal static bool TryInferTypeMapping( Type parameterType, Type argumentType, - Dictionary typeMapping) + Dictionary typeMapping, bool tupleElement = false, bool overwriteBindings = false) { // A populated Nullable boxes as T, including flattened tuple elements. if (Nullable.GetUnderlyingType(parameterType) is { } underlyingParameter && argumentType.IsValueType && Nullable.GetUnderlyingType(argumentType) is null) { - return TryInferTypeMapping(underlyingParameter, argumentType, typeMapping); + return TryInferTypeMapping(underlyingParameter, argumentType, typeMapping, tupleElement, overwriteBindings); } // Direct generic parameter if (parameterType.IsGenericParameter) { + // Reconstructed tuple elements preserve the generator's last-occurrence inference. + if (overwriteBindings) + { + typeMapping[parameterType] = argumentType; + return true; + } if (typeMapping.TryGetValue(parameterType, out var existingMapping)) { // Verify consistency @@ -656,7 +663,7 @@ private static bool TryInferTypeMapping( return TryInferTypeMapping( parameterType.GetElementType()!, argumentType.GetElementType()!, - typeMapping); + typeMapping, tupleElement, overwriteBindings); } // Generic types (e.g., List, Dictionary) @@ -667,7 +674,10 @@ private static bool TryInferTypeMapping( ? argumentType : argumentType.GetGenericTypeDefinition(); - if (paramGenericDef == argGenericDef) + // The tuple binder reconstructs a sole tuple argument across reference/value families. + // Infer the corresponding elements first, as the source generator does. + if (paramGenericDef == argGenericDef + || tupleElement && TupleHelper.IsTupleType(parameterType) && TupleHelper.IsTupleType(argumentType)) { var paramGenericArgs = parameterType.GetGenericArguments(); var argGenericArgs = argumentType.GetGenericArguments(); @@ -676,16 +686,66 @@ private static bool TryInferTypeMapping( { for (var i = 0; i < paramGenericArgs.Length; i++) { - if (!TryInferTypeMapping(paramGenericArgs[i], argGenericArgs[i], typeMapping)) + if (tupleElement && !overwriteBindings && !paramGenericArgs[i].ContainsGenericParameters) + continue; + // Tuple invocation converts closed elements (including nullable/numeric + // values). Only open elements contribute to generic inference. + if (tupleElement && TupleHelper.IsTupleType(parameterType) && !paramGenericArgs[i].ContainsGenericParameters) + continue; + // A sole tuple is reconstructed with conversions. Match the generator's + // last-element inference through structurally matching tuple elements. + if (tupleElement && TupleHelper.IsTupleType(parameterType)) + { + var parameterElement = paramGenericArgs[i]; + var argumentElement = argGenericArgs[i]; + if (Nullable.GetUnderlyingType(parameterElement) is { } nullableElement + && argumentElement.IsValueType) + { + parameterElement = nullableElement; + argumentElement = Nullable.GetUnderlyingType(argumentElement) ?? argumentElement; + } + if (parameterElement.IsGenericParameter) + { + if (!TryInferTypeMapping(parameterElement, argumentElement, typeMapping, + tupleElement, overwriteBindings)) return false; + continue; + } + } + if (!TryInferTypeMapping(paramGenericArgs[i], argGenericArgs[i], typeMapping, + tupleElement, overwriteBindings)) { return false; } } - return true; + if (!tupleElement || overwriteBindings) return true; + try + { + return SubstituteCandidateParameters(parameterType, typeMapping).IsAssignableFrom(argumentType); + } + catch (ArgumentException) + { + // Inferred arguments can violate this candidate's generic constraints. + // Reject it without preventing the caller from trying other candidates. + return false; + } } } } + // A reconstructed tuple element may be a derived instance of an open generic base. + if (tupleElement && parameterType is { IsGenericType: true, IsClass: true }) + { + var parameterDefinition = parameterType.GetGenericTypeDefinition(); + for (var baseType = argumentType.BaseType; baseType is not null; baseType = baseType.BaseType) + { + if (!baseType.IsGenericType || baseType.GetGenericTypeDefinition() != parameterDefinition) continue; + var candidateMapping = new Dictionary(typeMapping); + if (!TryInferTypeMapping(parameterType, baseType, candidateMapping, tupleElement: true)) continue; + foreach (var mapping in candidateMapping) typeMapping[mapping.Key] = mapping.Value; + return true; + } + } + // Handle case where parameter is a generic interface and argument implements it if (parameterType is { IsGenericType: true, IsInterface: true }) { @@ -705,10 +765,17 @@ private static bool TryInferTypeMapping( if (paramGenericArgs.Length == implGenericArgs.Length) { + var candidateMapping = new Dictionary(typeMapping); + if (tupleElement) + { + if (!TryInferTypeMapping(parameterType, implementedInterface, candidateMapping, tupleElement: true)) continue; + foreach (var mapping in candidateMapping) typeMapping[mapping.Key] = mapping.Value; + return true; + } var allMapped = true; for (var i = 0; i < paramGenericArgs.Length; i++) { - if (!TryInferTypeMapping(paramGenericArgs[i], implGenericArgs[i], typeMapping)) + if (!TryInferTypeMapping(paramGenericArgs[i], implGenericArgs[i], candidateMapping, tupleElement: tupleElement)) { allMapped = false; break; @@ -716,6 +783,7 @@ private static bool TryInferTypeMapping( } if (allMapped) { + foreach (var mapping in candidateMapping) typeMapping[mapping.Key] = mapping.Value; return true; } } @@ -724,8 +792,36 @@ private static bool TryInferTypeMapping( } } - // Non-generic types must match exactly or be assignable - return parameterType.IsAssignableFrom(argumentType); + // A reconstructed element with no structural match contributes no bindings. Its + // interface/base declaration may hide a compatible value, so defer the cast to invocation. + // Interface/base candidate validation never overwrites bindings and remains strict. + return tupleElement && overwriteBindings || parameterType.IsAssignableFrom(argumentType); + } + + // Open candidate types are only rebuilt during reflection inference. Validate the entire + // constructed type: assignability of its individual invariant arguments is insufficient. + [UnconditionalSuppressMessage("AOT", "IL3050", Justification = "Open generic tuple candidates are resolved only in reflection mode; source-generated tests are already closed.")] + [UnconditionalSuppressMessage("Trimming", "IL2055", Justification = "Candidate definitions and inferred arguments come from the test parameter and data types already in use.")] + private static Type SubstituteCandidateParameters(Type type, Dictionary bindings) + { + if (!type.ContainsGenericParameters) return type; + if (type.IsGenericParameter) return bindings.TryGetValue(type, out var bound) ? bound : type; + if (type.IsArray) + { + var element = type.GetElementType()!; + var substituted = SubstituteCandidateParameters(element, bindings); + return type == element.MakeArrayType() + ? substituted.MakeArrayType() + : substituted.MakeArrayType(type.GetArrayRank()); + } + if (type.IsGenericType) + { + var arguments = type.GetGenericArguments(); + for (var i = 0; i < arguments.Length; i++) + arguments[i] = SubstituteCandidateParameters(arguments[i], bindings); + return type.GetGenericTypeDefinition().MakeGenericType(arguments); + } + return type; } /// The constraints of the generic parameters that fill. diff --git a/tests/TUnit.Core.SourceGenerator.Tests/TupleInferenceTests.Test.verified.txt b/tests/TUnit.Core.SourceGenerator.Tests/TupleInferenceTests.Test.verified.txt new file mode 100644 index 00000000000..e4715c3f508 --- /dev/null +++ b/tests/TUnit.Core.SourceGenerator.Tests/TupleInferenceTests.Test.verified.txt @@ -0,0 +1,11960 @@ +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_NestedTupleWithTrailingParametersTests_ValueOptional___T__0B567705_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests)), + Name = "NestedTupleWithTrailingParametersTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueOptional", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests), "ValueOptional", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false) +})); + private static global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.ValueOptional((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (int)(5)); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.ValueOptional((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast(args[1])); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ValueOptional", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests.ValueOptional", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 8, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_NestedTupleWithTrailingParametersTests_ValueOptional___T__0B567705_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_NestedTupleWithTrailingParametersTests_ValueOptional___T__0B567705_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_NestedTupleWithTrailingParametersTests_ValueParams___T__s_4429EF19_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests)), + Name = "NestedTupleWithTrailingParametersTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueParams", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests), "ValueParams", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false) +})); + private static global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::System.Array.Empty()); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + case 3: + { + instance.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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: + if (args.Length < 1) + { + throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}"); + } + instance.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i]))) : global::System.Array.Empty())); + 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)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueParamsRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ValueParams", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests.ValueParams", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 18, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueParamsRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests.ValueParamsRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_NestedTupleWithTrailingParametersTests_ValueParams___T__s_4429EF19_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_NestedTupleWithTrailingParametersTests_ValueParams___T__s_4429EF19_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_NestedTupleWithTrailingParametersTests_ReferenceOptional__FEE23D53_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests)), + Name = "NestedTupleWithTrailingParametersTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceOptional", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests), "ReferenceOptional", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false) +})); + private static global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.ReferenceOptional((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (int)(5)); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.ReferenceOptional((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast(args[1])); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ReferenceOptional", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests.ReferenceOptional", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 26, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_NestedTupleWithTrailingParametersTests_ReferenceOptional__FEE23D53_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_NestedTupleWithTrailingParametersTests_ReferenceOptional__FEE23D53_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_NestedTupleWithTrailingParametersTests_ReferenceParams__T_48C40CFB_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests)), + Name = "NestedTupleWithTrailingParametersTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceParams", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests), "ReferenceParams", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false) +})); + private static global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::System.Array.Empty()); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + case 3: + { + instance.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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: + if (args.Length < 1) + { + throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}"); + } + instance.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i]))) : global::System.Array.Empty())); + 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)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceParamsRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ReferenceParams", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests.ReferenceParams", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 36, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceParamsRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.NestedTupleWithTrailingParametersTests.ReferenceParamsRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_NestedTupleWithTrailingParametersTests_ReferenceParams__T_48C40CFB_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_NestedTupleWithTrailingParametersTests_ReferenceParams__T_48C40CFB_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_ClosedNestedTupleConversionTests_ClosedNested___T___objec_6BE36798_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.ClosedNestedTupleConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.ClosedNestedTupleConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.ClosedNestedTupleConversionTests)), + Name = "ClosedNestedTupleConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.ClosedNestedTupleConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ClosedNested", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.ClosedNestedTupleConversionTests), "ClosedNested", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "pair", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(global::System.ValueTuple?), "extra", new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple?)), true) +})); + private static global::TUnit.TestProject.Bugs._7629.ClosedNestedTupleConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.ClosedNestedTupleConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.ClosedNestedTupleConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), (__tupleElements[1] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })) }; + } + switch (args.Length) + { + case 1: + { + instance.ClosedNested((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple>)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), (__tupleInput0[1] switch { var __tupleValue1 when __tupleValue1 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue1) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue1) is { Length: 2 } __tupleInput1 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput1[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput1[1])), var __tupleFallback1 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback1) })), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleFallback0) }), default(global::System.ValueTuple?)!); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.ClosedNested((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple>)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), (__tupleInput0[1] switch { var __tupleValue1 when __tupleValue1 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue1) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue1) is { Length: 2 } __tupleInput1 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput1[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput1[1])), var __tupleFallback1 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback1) })), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleFallback0) }), (args[1] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple?)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast?>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ClosedNested", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ClosedNestedTupleConversionTests.ClosedNested", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 50, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ClosedNestedTupleConversionTests.Rows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple>)) }, __mm_0.Parameters[1] with { Type = typeof(global::System.ValueTuple?), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple?)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_ClosedNestedTupleConversionTests_ClosedNested___T___objec_6BE36798_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_ClosedNestedTupleConversionTests_ClosedNested___T___objec_6BE36798_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_RepeatedTupleBindingTests_RepeatedValue___T__T__int_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests)), + Name = "RepeatedTupleBindingTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("RepeatedValue", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests), "RepeatedValue", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.GenericParameter(0, true, "T")]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false) +})); + private static global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.RepeatedValue((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (int)(0)); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.RepeatedValue((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast(args[1])); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "RepeatedValue", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests.RepeatedValue", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 66, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_RepeatedTupleBindingTests_RepeatedValue___T__T__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_RepeatedTupleBindingTests_RepeatedValue___T__T__int_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_RepeatedTupleBindingTests_RepeatedReference__Tuple_T__T___2B1A4646_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests)), + Name = "RepeatedTupleBindingTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("RepeatedReference", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests), "RepeatedReference", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.GenericParameter(0, true, "T")]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(global::System.Tuple), "extra", new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)), true) +})); + private static global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.RepeatedReference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), default(global::System.Tuple)!); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.RepeatedReference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args[1] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "RepeatedReference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests.RepeatedReference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 74, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) }, __mm_0.Parameters[1] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_RepeatedTupleBindingTests_RepeatedReference__Tuple_T__T___2B1A4646_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_RepeatedTupleBindingTests_RepeatedReference__Tuple_T__T___2B1A4646_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_RepeatedTupleBindingTests_RepeatedWhole___T__T__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests)), + Name = "RepeatedTupleBindingTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("RepeatedWhole", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests), "RepeatedWhole", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.GenericParameter(0, true, "T")]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.RepeatedWhole((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.RepeatedWhole((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("WholeRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "RepeatedWhole", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests.RepeatedWhole", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 82, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("WholeRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.RepeatedTupleBindingTests.WholeRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_RepeatedTupleBindingTests_RepeatedWhole___T__T__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_RepeatedTupleBindingTests_RepeatedWhole___T__T__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_OpenTupleAssignabilityTests_ValueAssignable___T__object__string_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests)), + Name = "OpenTupleAssignabilityTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueAssignable", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests), "ValueAssignable", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(object))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(string), "extra", new global::TUnit.Core.ConcreteType(typeof(string)), false) +})); + private static global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.ValueAssignable((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (string)("")); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.ValueAssignable((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast(args[1])); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ValueAssignable", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests.ValueAssignable", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 98, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(string), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(string)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_OpenTupleAssignabilityTests_ValueAssignable___T__object__string_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_OpenTupleAssignabilityTests_ValueAssignable___T__object__string_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_OpenTupleAssignabilityTests_ReferenceAssignable__Tuple_T__9C75CF4E_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests)), + Name = "OpenTupleAssignabilityTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceAssignable", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests), "ReferenceAssignable", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(object))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(string), "extra", new global::TUnit.Core.ConcreteType(typeof(string)), false) +})); + private static global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.ReferenceAssignable((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (string)("")); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.ReferenceAssignable((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast(args[1])); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ReferenceAssignable", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests.ReferenceAssignable", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 106, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) }, __mm_0.Parameters[1] with { Type = typeof(string), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(string)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_OpenTupleAssignabilityTests_ReferenceAssignable__Tuple_T__9C75CF4E_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_OpenTupleAssignabilityTests_ReferenceAssignable__Tuple_T__9C75CF4E_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_OpenTupleAssignabilityTests_CrossFamily___T__string__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests)), + Name = "OpenTupleAssignabilityTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("CrossFamily", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests), "CrossFamily", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.CrossFamily((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.CrossFamily((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("CrossFamilyRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "CrossFamily", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests.CrossFamily", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 114, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("CrossFamilyRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.OpenTupleAssignabilityTests.CrossFamilyRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_OpenTupleAssignabilityTests_CrossFamily___T__string__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_OpenTupleAssignabilityTests_CrossFamily___T__string__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_NarrowNumericElement___T__short__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests)), + Name = "SingleTupleElementConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("NarrowNumericElement", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), "NarrowNumericElement", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(short))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.NarrowNumericElement((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.NarrowNumericElement((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "NarrowNumericElement", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.NarrowNumericElement", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 132, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.Rows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_NarrowNumericElement___T__short__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_NarrowNumericElement___T__short__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_NarrowNumericReferenceE_A3294AFB_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests)), + Name = "SingleTupleElementConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("NarrowNumericReferenceElement", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), "NarrowNumericReferenceElement", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(short))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.NarrowNumericReferenceElement(new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.NarrowNumericReferenceElement((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("NarrowReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "NarrowNumericReferenceElement", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.NarrowNumericReferenceElement", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 140, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("NarrowReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.NarrowReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_NarrowNumericReferenceE_A3294AFB_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_NarrowNumericReferenceE_A3294AFB_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_EnumElement___T__DayOfWeek__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests)), + Name = "SingleTupleElementConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("EnumElement", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), "EnumElement", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(global::System.DayOfWeek))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.EnumElement((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.EnumElement((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "EnumElement", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.EnumElement", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 148, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.Rows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_EnumElement___T__DayOfWeek__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_EnumElement___T__DayOfWeek__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_EnumReferenceElement__T_6D457409_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests)), + Name = "SingleTupleElementConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("EnumReferenceElement", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), "EnumReferenceElement", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(global::System.DayOfWeek))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.EnumReferenceElement(new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.EnumReferenceElement((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("NarrowReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "EnumReferenceElement", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.EnumReferenceElement", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 156, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("NarrowReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.NarrowReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_EnumReferenceElement__T_6D457409_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_EnumReferenceElement__T_6D457409_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_ConvertibleElement___T__int__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests)), + Name = "SingleTupleElementConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ConvertibleElement", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), "ConvertibleElement", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(int))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.ConvertibleElement((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.ConvertibleElement((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ConvertibleRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ConvertibleElement", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.ConvertibleElement", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 167, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ConvertibleRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.ConvertibleRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_ConvertibleElement___T__int__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_ConvertibleElement___T__int__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_ConvertibleReferenceEle_88A71C15_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests)), + Name = "SingleTupleElementConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ConvertibleReferenceElement", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), "ConvertibleReferenceElement", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(bool?))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.ConvertibleReferenceElement(new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.ConvertibleReferenceElement((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ConvertibleReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ConvertibleReferenceElement", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.ConvertibleReferenceElement", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 175, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ConvertibleReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.ConvertibleReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_ConvertibleReferenceEle_88A71C15_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_ConvertibleReferenceEle_88A71C15_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_StringElement___T__int__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests)), + Name = "SingleTupleElementConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("StringElement", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), "StringElement", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(int))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.StringElement((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.StringElement((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("StringRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "StringElement", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.StringElement", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 186, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("StringRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.StringRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_StringElement___T__int__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_StringElement___T__int__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_StringReferenceElement__1830CF72_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests)), + Name = "SingleTupleElementConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("StringReferenceElement", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), "StringReferenceElement", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(decimal?))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.StringReferenceElement(new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.StringReferenceElement((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("StringReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "StringReferenceElement", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.StringReferenceElement", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 194, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("StringReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.StringReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_StringReferenceElement__1830CF72_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_StringReferenceElement__1830CF72_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_OperatorElement___T__De_67507020_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests)), + Name = "SingleTupleElementConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("OperatorElement", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), "OperatorElement", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.Destination))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.OperatorElement((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.OperatorElement((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("OperatorRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "OperatorElement", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.OperatorElement", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 212, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("OperatorRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.OperatorRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_OperatorElement___T__De_67507020_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_OperatorElement___T__De_67507020_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_OperatorReferenceElemen_1147B1A7_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests)), + Name = "SingleTupleElementConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("OperatorReferenceElement", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), "OperatorReferenceElement", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.Destination))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.OperatorReferenceElement(new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.OperatorReferenceElement((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("OperatorReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "OperatorReferenceElement", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.OperatorReferenceElement", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 220, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("OperatorReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.OperatorReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_OperatorReferenceElemen_1147B1A7_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_OperatorReferenceElemen_1147B1A7_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_BaseElement___Base_T___T__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests)), + Name = "SingleTupleElementConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("BaseElement", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), "BaseElement", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.Base<>), [new global::TUnit.Core.GenericParameter(0, true, "T")]), new global::TUnit.Core.GenericParameter(0, true, "T")]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.BaseElement((global::TUnit.Core.Helpers.CastHelper.Cast>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.BaseElement((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple, int>)(global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast, int>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("BaseRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "BaseElement", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.BaseElement", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 234, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("BaseRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.BaseRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple, int>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple, int>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_BaseElement___Base_T___T__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_BaseElement___Base_T___T__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_BaseReferenceElement__T_B9459DB7_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests)), + Name = "SingleTupleElementConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("BaseReferenceElement", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), "BaseReferenceElement", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.Base<>), [new global::TUnit.Core.GenericParameter(0, true, "T")]), new global::TUnit.Core.GenericParameter(0, true, "T")]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.BaseReferenceElement(new global::System.Tuple, int>(global::TUnit.Core.Helpers.CastHelper.Cast>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.BaseReferenceElement((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple, int>)new global::System.Tuple, int>(global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast, int>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("BaseReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "BaseReferenceElement", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.BaseReferenceElement", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 242, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("BaseReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.BaseReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple, int>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple, int>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_BaseReferenceElement__T_B9459DB7_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_BaseReferenceElement__T_B9459DB7_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_InterfaceElement___IEnu_E5456126_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests)), + Name = "SingleTupleElementConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("InterfaceElement", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), "InterfaceElement", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Collections.Generic.IEnumerable<>), [new global::TUnit.Core.GenericParameter(0, true, "T")]), new global::TUnit.Core.GenericParameter(0, true, "T")]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.InterfaceElement((global::TUnit.Core.Helpers.CastHelper.Cast>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.InterfaceElement((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple, int>)(global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast, int>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("InterfaceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "InterfaceElement", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.InterfaceElement", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 253, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("InterfaceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.InterfaceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple, int>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple, int>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_InterfaceElement___IEnu_E5456126_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_InterfaceElement___IEnu_E5456126_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_InterfaceReferenceEleme_5190ADC3_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests)), + Name = "SingleTupleElementConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("InterfaceReferenceElement", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), "InterfaceReferenceElement", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Collections.Generic.IEnumerable<>), [new global::TUnit.Core.GenericParameter(0, true, "T")]), new global::TUnit.Core.GenericParameter(0, true, "T")]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.InterfaceReferenceElement(new global::System.Tuple, int>(global::TUnit.Core.Helpers.CastHelper.Cast>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.InterfaceReferenceElement((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple, int>)new global::System.Tuple, int>(global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast, int>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("InterfaceReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "InterfaceReferenceElement", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.InterfaceReferenceElement", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 261, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("InterfaceReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.InterfaceReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple, int>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple, int>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_InterfaceReferenceEleme_5190ADC3_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_InterfaceReferenceEleme_5190ADC3_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_NullableElement___T__int___TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests)), + Name = "SingleTupleElementConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("NullableElement", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), "NullableElement", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(int?))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.NullableElement((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.NullableElement((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "NullableElement", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.NullableElement", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 269, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.Rows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_NullableElement___T__int___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_NullableElement___T__int___TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_OpenNullableElement___T_A2EDA55B_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests)), + Name = "SingleTupleElementConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("OpenNullableElement", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), "OpenNullableElement", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Nullable<>), [new global::TUnit.Core.GenericParameter(0, true, "T")]), new global::TUnit.Core.ConcreteType(typeof(string))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.OpenNullableElement((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.OpenNullableElement((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("OpenNullableRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "OpenNullableElement", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.OpenNullableElement", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 280, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("OpenNullableRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.OpenNullableRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_OpenNullableElement___T_A2EDA55B_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_OpenNullableElement___T_A2EDA55B_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_OpenNullableReferenceEl_0B1C1B14_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests)), + Name = "SingleTupleElementConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("OpenNullableReferenceElement", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), "OpenNullableReferenceElement", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Nullable<>), [new global::TUnit.Core.GenericParameter(0, true, "T")]), new global::TUnit.Core.ConcreteType(typeof(string))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.OpenNullableReferenceElement(new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.OpenNullableReferenceElement((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("OpenNullableReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "OpenNullableReferenceElement", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.OpenNullableReferenceElement", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 288, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("OpenNullableReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.OpenNullableReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_OpenNullableReferenceEl_0B1C1B14_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_OpenNullableReferenceEl_0B1C1B14_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_NumericElement___T__long__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests)), + Name = "SingleTupleElementConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("NumericElement", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests), "NumericElement", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(long))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.NumericElement((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.NumericElement((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "NumericElement", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.NumericElement", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 296, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingleTupleElementConversionTests.Rows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_NumericElement___T__long__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingleTupleElementConversionTests_NumericElement___T__long__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_BoxedTupleElementConversionTests_Value___T__int__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.BoxedTupleElementConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.BoxedTupleElementConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.BoxedTupleElementConversionTests)), + Name = "BoxedTupleElementConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.BoxedTupleElementConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Value", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.BoxedTupleElementConversionTests), "Value", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(int))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.BoxedTupleElementConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.BoxedTupleElementConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.BoxedTupleElementConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Value((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Value((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Value", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.BoxedTupleElementConversionTests.Value", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 311, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.BoxedTupleElementConversionTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_BoxedTupleElementConversionTests_Value___T__int__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_BoxedTupleElementConversionTests_Value___T__int__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_BoxedTupleElementConversionTests_Reference__Tuple_T__int__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.BoxedTupleElementConversionTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.BoxedTupleElementConversionTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.BoxedTupleElementConversionTests)), + Name = "BoxedTupleElementConversionTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.BoxedTupleElementConversionTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Reference", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.BoxedTupleElementConversionTests), "Reference", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(int))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.BoxedTupleElementConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.BoxedTupleElementConversionTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.BoxedTupleElementConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.Reference(new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.Reference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Reference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.BoxedTupleElementConversionTests.Reference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 319, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.BoxedTupleElementConversionTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_BoxedTupleElementConversionTests_Reference__Tuple_T__int__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_BoxedTupleElementConversionTests_Reference__Tuple_T__int__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_WholeReferenceTupleSourceTests_WholeRow__T_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.WholeReferenceTupleSourceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.WholeReferenceTupleSourceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.WholeReferenceTupleSourceTests)), + Name = "WholeReferenceTupleSourceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.WholeReferenceTupleSourceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("WholeRow", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.WholeReferenceTupleSourceTests), "WholeRow", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.GenericParameter(0, true, "T"), false) +})); + private static global::TUnit.TestProject.Bugs._7629.WholeReferenceTupleSourceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.WholeReferenceTupleSourceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.WholeReferenceTupleSourceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.WholeRow>(new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.WholeRow>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(global::System.Tuple)), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "WholeRow>", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.WholeReferenceTupleSourceTests.WholeRow>", + methodTypeArgumentsIdentity: ">", + filePath: "", + lineNumber: 332, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.WholeReferenceTupleSourceTests.Rows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_WholeReferenceTupleSourceTests_WholeRow__T_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_WholeReferenceTupleSourceTests_WholeRow__T_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_InferredReferenceTupleSourceTests_Element__T_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.InferredReferenceTupleSourceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.InferredReferenceTupleSourceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.InferredReferenceTupleSourceTests)), + Name = "InferredReferenceTupleSourceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.InferredReferenceTupleSourceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Element", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.InferredReferenceTupleSourceTests), "Element", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "value", new global::TUnit.Core.GenericParameter(0, true, "T"), false) +})); + private static global::TUnit.TestProject.Bugs._7629.InferredReferenceTupleSourceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.InferredReferenceTupleSourceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.InferredReferenceTupleSourceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + instance.Element(global::TUnit.Core.Helpers.CastHelper.Cast(args[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)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Element", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.InferredReferenceTupleSourceTests.Element", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 348, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.InferredReferenceTupleSourceTests.Rows()), + }, +}, + methodMetadata: __mm_0, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_InferredReferenceTupleSourceTests_Element__T_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_InferredReferenceTupleSourceTests_Element__T_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_TupleInterfaceCandidateIsolationTests_Value___T__IEnumerable_T___TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.TupleInterfaceCandidateIsolationTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.TupleInterfaceCandidateIsolationTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.TupleInterfaceCandidateIsolationTests)), + Name = "TupleInterfaceCandidateIsolationTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.TupleInterfaceCandidateIsolationTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Value", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.TupleInterfaceCandidateIsolationTests), "Value", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Collections.Generic.IEnumerable<>), [new global::TUnit.Core.GenericParameter(0, true, "T")])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.TupleInterfaceCandidateIsolationTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.TupleInterfaceCandidateIsolationTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.TupleInterfaceCandidateIsolationTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Value((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Value((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple>)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Value", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.TupleInterfaceCandidateIsolationTests.Value", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 369, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.TupleInterfaceCandidateIsolationTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_TupleInterfaceCandidateIsolationTests_Value___T__IEnumerable_T___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_TupleInterfaceCandidateIsolationTests_Value___T__IEnumerable_T___TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_TupleInterfaceCandidateIsolationTests_Reference__Tuple_T__6B2099BC_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.TupleInterfaceCandidateIsolationTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.TupleInterfaceCandidateIsolationTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.TupleInterfaceCandidateIsolationTests)), + Name = "TupleInterfaceCandidateIsolationTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.TupleInterfaceCandidateIsolationTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Reference", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.TupleInterfaceCandidateIsolationTests), "Reference", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Collections.Generic.IEnumerable<>), [new global::TUnit.Core.GenericParameter(0, true, "T")])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.TupleInterfaceCandidateIsolationTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.TupleInterfaceCandidateIsolationTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.TupleInterfaceCandidateIsolationTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.Reference(new global::System.Tuple>(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.Reference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple>)new global::System.Tuple>(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Reference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.TupleInterfaceCandidateIsolationTests.Reference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 377, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.TupleInterfaceCandidateIsolationTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_TupleInterfaceCandidateIsolationTests_Reference__Tuple_T__6B2099BC_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_TupleInterfaceCandidateIsolationTests_Reference__Tuple_T__6B2099BC_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_WholeTupleWithTrailingParametersTests_ValueOptional___T___B8FAFB69_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests)), + Name = "WholeTupleWithTrailingParametersTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueOptional", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests), "ValueOptional", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false) +})); + private static global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.ValueOptional((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (int)(5)); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.ValueOptional((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast(args[1])); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ValueOptional", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests.ValueOptional", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 393, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_WholeTupleWithTrailingParametersTests_ValueOptional___T___B8FAFB69_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_WholeTupleWithTrailingParametersTests_ValueOptional___T___B8FAFB69_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_WholeTupleWithTrailingParametersTests_ValueParams___T__st_A676A98D_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests)), + Name = "WholeTupleWithTrailingParametersTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueParams", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests), "ValueParams", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false) +})); + private static global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::System.Array.Empty()); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + case 3: + { + instance.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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: + if (args.Length < 1) + { + throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}"); + } + instance.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i]))) : global::System.Array.Empty())); + 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)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ValueParams", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests.ValueParams", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 401, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_WholeTupleWithTrailingParametersTests_ValueParams___T__st_A676A98D_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_WholeTupleWithTrailingParametersTests_ValueParams___T__st_A676A98D_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_WholeTupleWithTrailingParametersTests_ValueArray___T__str_80E141BC_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests)), + Name = "WholeTupleWithTrailingParametersTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueArray", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests), "ValueArray", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false) +})); + private static global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.ValueArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::System.Array.Empty()); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.ValueArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + case 3: + { + instance.ValueArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ValueArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ValueArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ValueArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ValueArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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: + if (args.Length < 1) + { + throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}"); + } + instance.ValueArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i]))) : global::System.Array.Empty())); + 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)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ValueArray", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests.ValueArray", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 409, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_WholeTupleWithTrailingParametersTests_ValueArray___T__str_80E141BC_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_WholeTupleWithTrailingParametersTests_ValueArray___T__str_80E141BC_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_WholeTupleWithTrailingParametersTests_ReferenceOptional___0BA334AF_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests)), + Name = "WholeTupleWithTrailingParametersTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceOptional", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests), "ReferenceOptional", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false) +})); + private static global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.ReferenceOptional((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (int)(5)); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.ReferenceOptional((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast(args[1])); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ReferenceOptional", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests.ReferenceOptional", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 417, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_WholeTupleWithTrailingParametersTests_ReferenceOptional___0BA334AF_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_WholeTupleWithTrailingParametersTests_ReferenceOptional___0BA334AF_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_WholeTupleWithTrailingParametersTests_ReferenceParams__Tu_AFB56C97_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests)), + Name = "WholeTupleWithTrailingParametersTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceParams", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests), "ReferenceParams", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false) +})); + private static global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::System.Array.Empty()); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + case 3: + { + instance.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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: + if (args.Length < 1) + { + throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}"); + } + instance.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i]))) : global::System.Array.Empty())); + 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)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ReferenceParams", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests.ReferenceParams", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 425, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_WholeTupleWithTrailingParametersTests_ReferenceParams__Tu_AFB56C97_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_WholeTupleWithTrailingParametersTests_ReferenceParams__Tu_AFB56C97_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_WholeTupleWithTrailingParametersTests_ReferenceArray__Tup_56CC26C4_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests)), + Name = "WholeTupleWithTrailingParametersTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceArray", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests), "ReferenceArray", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false) +})); + private static global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.ReferenceArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::System.Array.Empty()); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.ReferenceArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + case 3: + { + instance.ReferenceArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ReferenceArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ReferenceArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ReferenceArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ReferenceArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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: + if (args.Length < 1) + { + throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}"); + } + instance.ReferenceArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i]))) : global::System.Array.Empty())); + 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)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ReferenceArray", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests.ReferenceArray", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 433, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.WholeTupleWithTrailingParametersTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_WholeTupleWithTrailingParametersTests_ReferenceArray__Tup_56CC26C4_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_WholeTupleWithTrailingParametersTests_ReferenceArray__Tup_56CC26C4_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_RepeatedConvertibleTupleTests_Value___T__T__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.RepeatedConvertibleTupleTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.RepeatedConvertibleTupleTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.RepeatedConvertibleTupleTests)), + Name = "RepeatedConvertibleTupleTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.RepeatedConvertibleTupleTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Value", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.RepeatedConvertibleTupleTests), "Value", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.GenericParameter(0, true, "T")]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.RepeatedConvertibleTupleTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.RepeatedConvertibleTupleTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.RepeatedConvertibleTupleTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Value((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Value((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Value", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.RepeatedConvertibleTupleTests.Value", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 448, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.RepeatedConvertibleTupleTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_RepeatedConvertibleTupleTests_Value___T__T__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_RepeatedConvertibleTupleTests_Value___T__T__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_RepeatedConvertibleTupleTests_Reference__Tuple_T__T__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.RepeatedConvertibleTupleTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.RepeatedConvertibleTupleTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.RepeatedConvertibleTupleTests)), + Name = "RepeatedConvertibleTupleTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.RepeatedConvertibleTupleTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Reference", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.RepeatedConvertibleTupleTests), "Reference", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.GenericParameter(0, true, "T")]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.RepeatedConvertibleTupleTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.RepeatedConvertibleTupleTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.RepeatedConvertibleTupleTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.Reference(new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.Reference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Reference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.RepeatedConvertibleTupleTests.Reference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 456, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.RepeatedConvertibleTupleTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_RepeatedConvertibleTupleTests_Reference__Tuple_T__T__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_RepeatedConvertibleTupleTests_Reference__Tuple_T__T__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_RepeatedNullableTupleTests_Value___T__T___TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests)), + Name = "RepeatedNullableTupleTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Value", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests), "Value", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Nullable<>), [new global::TUnit.Core.GenericParameter(0, true, "T")])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Value((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Value((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows"), + new global::TUnit.Core.MethodDataSourceAttribute("NullableRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Value", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests.Value", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 473, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests.ValueRows()), + }, + new global::TUnit.Core.MethodDataSourceAttribute("NullableRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests.NullableRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_RepeatedNullableTupleTests_Value___T__T___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_RepeatedNullableTupleTests_Value___T__T___TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_RepeatedNullableTupleTests_Reference__Tuple_T__T___TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests)), + Name = "RepeatedNullableTupleTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Reference", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests), "Reference", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Nullable<>), [new global::TUnit.Core.GenericParameter(0, true, "T")])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.Reference(new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.Reference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows"), + new global::TUnit.Core.MethodDataSourceAttribute("NullableReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Reference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests.Reference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 483, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests.ReferenceRows()), + }, + new global::TUnit.Core.MethodDataSourceAttribute("NullableReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.RepeatedNullableTupleTests.NullableReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_RepeatedNullableTupleTests_Reference__Tuple_T__T___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_RepeatedNullableTupleTests_Reference__Tuple_T__T___TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_RepeatedNestedGenericTupleTests_Value___T__List_T___TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests)), + Name = "RepeatedNestedGenericTupleTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Value", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests), "Value", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Collections.Generic.List<>), [new global::TUnit.Core.GenericParameter(0, true, "T")])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Value((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Value((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple>)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Value", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests.Value", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 500, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_RepeatedNestedGenericTupleTests_Value___T__List_T___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_RepeatedNestedGenericTupleTests_Value___T__List_T___TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_RepeatedNestedGenericTupleTests_Reference__Tuple_T__List_T___TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests)), + Name = "RepeatedNestedGenericTupleTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Reference", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests), "Reference", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Collections.Generic.List<>), [new global::TUnit.Core.GenericParameter(0, true, "T")])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.Reference(new global::System.Tuple>(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.Reference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple>)new global::System.Tuple>(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Reference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests.Reference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 508, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_RepeatedNestedGenericTupleTests_Reference__Tuple_T__List_T___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_RepeatedNestedGenericTupleTests_Reference__Tuple_T__List_T___TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_RepeatedNestedGenericTupleTests_Array___T__T____TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests)), + Name = "RepeatedNestedGenericTupleTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Array", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests), "Array", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(object))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Array((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Array((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ArrayRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Array", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests.Array", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 516, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ArrayRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.RepeatedNestedGenericTupleTests.ArrayRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_RepeatedNestedGenericTupleTests_Array___T__T____TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_RepeatedNestedGenericTupleTests_Array___T__T____TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_OrdinaryGenericBaseInferenceTests_Ordinary__Base_T__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.OrdinaryGenericBaseInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.OrdinaryGenericBaseInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.OrdinaryGenericBaseInferenceTests)), + Name = "OrdinaryGenericBaseInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.OrdinaryGenericBaseInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Ordinary", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.OrdinaryGenericBaseInferenceTests), "Ordinary", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "value", new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.OrdinaryGenericBaseInferenceTests.Base<>), [new global::TUnit.Core.GenericParameter(0, true, "T")]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.OrdinaryGenericBaseInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.OrdinaryGenericBaseInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.OrdinaryGenericBaseInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(new global::TUnit.Core.Exceptions.GenericTypeResolutionException("Could not infer the type arguments of generic test method 'Ordinary' from data source [MethodDataSource(nameof(Rows))]. Source-generated mode infers type arguments at compile time from the data source's declared type, not from the run-time type of its values, and that declared type does not determine them. Declare the data source with a type that does (for example IEnumerable> rather than IEnumerable), or list the type arguments with [GenerateGenericTest]."))); + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Ordinary", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.OrdinaryGenericBaseInferenceTests.Ordinary", + filePath: "", + lineNumber: 532, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + global::TUnit.Core.GenericConstraintViolationDataSource.Create("Could not infer the type arguments of generic test method 'Ordinary' from data source [MethodDataSource(nameof(Rows))]. Source-generated mode infers type arguments at compile time from the data source's declared type, not from the run-time type of its values, and that declared type does not determine them. Declare the data source with a type that does (for example IEnumerable> rather than IEnumerable), or list the type arguments with [GenerateGenericTest].", new global::TUnit.Core.MethodDataSourceAttribute("Rows") +{ + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.OrdinaryGenericBaseInferenceTests.Rows()), +}), +}, + methodMetadata: __mm_0, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_OrdinaryGenericBaseInferenceTests_Ordinary__Base_T__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_OrdinaryGenericBaseInferenceTests_Ordinary__Base_T__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_TupleNestedInterfaceBaseTests_Value___IEnumerable_Base_T____int__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests)), + Name = "TupleNestedInterfaceBaseTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Value", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests), "Value", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Collections.Generic.IEnumerable<>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests.Base<>), [new global::TUnit.Core.GenericParameter(0, true, "T")])]), new global::TUnit.Core.ConcreteType(typeof(int))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Value((global::TUnit.Core.Helpers.CastHelper.Cast>>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Value((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple>, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple>, int>)(global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>, int>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Value", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests.Value", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 547, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests.Rows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple>, int>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple>, int>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_TupleNestedInterfaceBaseTests_Value___IEnumerable_Base_T____int__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_TupleNestedInterfaceBaseTests_Value___IEnumerable_Base_T____int__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_TupleNestedInterfaceBaseTests_Reference__Tuple_IEnumerabl_07FD9449_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests)), + Name = "TupleNestedInterfaceBaseTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Reference", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests), "Reference", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Collections.Generic.IEnumerable<>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests.Base<>), [new global::TUnit.Core.GenericParameter(0, true, "T")])]), new global::TUnit.Core.ConcreteType(typeof(int))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.Reference(new global::System.Tuple>, int>(global::TUnit.Core.Helpers.CastHelper.Cast>>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.Reference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple>, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple>, int>)new global::System.Tuple>, int>(global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>, int>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Reference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests.Reference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 555, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.TupleNestedInterfaceBaseTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple>, int>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple>, int>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_TupleNestedInterfaceBaseTests_Reference__Tuple_IEnumerabl_07FD9449_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_TupleNestedInterfaceBaseTests_Reference__Tuple_IEnumerabl_07FD9449_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_TupleMultiParameterCandidateTests_Value___T__IPair_U__T___TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests)), + Name = "TupleMultiParameterCandidateTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Value", __classType, typeof(void), __classMetadata, genericTypeCount: 2, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests), "Value", false, 2, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests.IPair<,>), [new global::TUnit.Core.GenericParameter(1, true, "U"), new global::TUnit.Core.GenericParameter(0, true, "T")])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Value((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Value((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple>)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Value", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests.Value", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 571, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests.Rows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_TupleMultiParameterCandidateTests_Value___T__IPair_U__T___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_TupleMultiParameterCandidateTests_Value___T__IPair_U__T___TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_TupleMultiParameterCandidateTests_Reference__Tuple_T__IPair_U__T___TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests)), + Name = "TupleMultiParameterCandidateTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Reference", __classType, typeof(void), __classMetadata, genericTypeCount: 2, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests), "Reference", false, 2, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests.IPair<,>), [new global::TUnit.Core.GenericParameter(1, true, "U"), new global::TUnit.Core.GenericParameter(0, true, "T")])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.Reference(new global::System.Tuple>(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.Reference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple>)new global::System.Tuple>(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Reference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests.Reference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 579, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.TupleMultiParameterCandidateTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_TupleMultiParameterCandidateTests_Reference__Tuple_T__IPair_U__T___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_TupleMultiParameterCandidateTests_Reference__Tuple_T__IPair_U__T___TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SpreadCrossFamilyTupleInferenceTests_Value___T__string__int_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SpreadCrossFamilyTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SpreadCrossFamilyTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SpreadCrossFamilyTupleInferenceTests)), + Name = "SpreadCrossFamilyTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SpreadCrossFamilyTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Value", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SpreadCrossFamilyTupleInferenceTests), "Value", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SpreadCrossFamilyTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SpreadCrossFamilyTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SpreadCrossFamilyTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(new global::TUnit.Core.Exceptions.GenericTypeResolutionException("Could not infer the type arguments of generic test method 'Value' from data source [MethodDataSource(nameof(Rows))]. Source-generated mode infers type arguments at compile time from the data source's declared type, not from the run-time type of its values, and that declared type does not determine them. Declare the data source with a type that does (for example IEnumerable> rather than IEnumerable), or list the type arguments with [GenerateGenericTest]."))); + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Value", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SpreadCrossFamilyTupleInferenceTests.Value", + filePath: "", + lineNumber: 593, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + global::TUnit.Core.GenericConstraintViolationDataSource.Create("Could not infer the type arguments of generic test method 'Value' from data source [MethodDataSource(nameof(Rows))]. Source-generated mode infers type arguments at compile time from the data source's declared type, not from the run-time type of its values, and that declared type does not determine them. Declare the data source with a type that does (for example IEnumerable> rather than IEnumerable), or list the type arguments with [GenerateGenericTest].", new global::TUnit.Core.MethodDataSourceAttribute("Rows") +{ + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SpreadCrossFamilyTupleInferenceTests.Rows()), +}), +}, + methodMetadata: __mm_0, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SpreadCrossFamilyTupleInferenceTests_Value___T__string__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SpreadCrossFamilyTupleInferenceTests_Value___T__string__int_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_TupleClosedCandidateArgumentTests_Value___T__IPair_U__int___TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests)), + Name = "TupleClosedCandidateArgumentTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Value", __classType, typeof(void), __classMetadata, genericTypeCount: 2, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests), "Value", false, 2, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests.IPair<,>), [new global::TUnit.Core.GenericParameter(1, true, "U"), new global::TUnit.Core.ConcreteType(typeof(int))])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Value((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Value((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple>)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Value", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests.Value", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 607, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests.Rows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_TupleClosedCandidateArgumentTests_Value___T__IPair_U__int___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_TupleClosedCandidateArgumentTests_Value___T__IPair_U__int___TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_TupleClosedCandidateArgumentTests_Reference__Tuple_T__IPa_E32FFA62_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests)), + Name = "TupleClosedCandidateArgumentTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Reference", __classType, typeof(void), __classMetadata, genericTypeCount: 2, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests), "Reference", false, 2, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests.IPair<,>), [new global::TUnit.Core.GenericParameter(1, true, "U"), new global::TUnit.Core.ConcreteType(typeof(int))])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.Reference(new global::System.Tuple>(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.Reference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple>)new global::System.Tuple>(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Reference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests.Reference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 615, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.TupleClosedCandidateArgumentTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_TupleClosedCandidateArgumentTests_Reference__Tuple_T__IPa_E32FFA62_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_TupleClosedCandidateArgumentTests_Reference__Tuple_T__IPa_E32FFA62_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SpreadMatchingFamilyTupleInferenceTests_Value___Base_T___int__int_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SpreadMatchingFamilyTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SpreadMatchingFamilyTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SpreadMatchingFamilyTupleInferenceTests)), + Name = "SpreadMatchingFamilyTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SpreadMatchingFamilyTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Value", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SpreadMatchingFamilyTupleInferenceTests), "Value", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.SpreadMatchingFamilyTupleInferenceTests.Base<>), [new global::TUnit.Core.GenericParameter(0, true, "T")]), new global::TUnit.Core.ConcreteType(typeof(int))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SpreadMatchingFamilyTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SpreadMatchingFamilyTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SpreadMatchingFamilyTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(new global::TUnit.Core.Exceptions.GenericTypeResolutionException("Could not infer the type arguments of generic test method 'Value' from data source [MethodDataSource(nameof(Rows))]. Source-generated mode infers type arguments at compile time from the data source's declared type, not from the run-time type of its values, and that declared type does not determine them. Declare the data source with a type that does (for example IEnumerable> rather than IEnumerable), or list the type arguments with [GenerateGenericTest]."))); + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Value", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SpreadMatchingFamilyTupleInferenceTests.Value", + filePath: "", + lineNumber: 630, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + global::TUnit.Core.GenericConstraintViolationDataSource.Create("Could not infer the type arguments of generic test method 'Value' from data source [MethodDataSource(nameof(Rows))]. Source-generated mode infers type arguments at compile time from the data source's declared type, not from the run-time type of its values, and that declared type does not determine them. Declare the data source with a type that does (for example IEnumerable> rather than IEnumerable), or list the type arguments with [GenerateGenericTest].", new global::TUnit.Core.MethodDataSourceAttribute("Rows") +{ + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SpreadMatchingFamilyTupleInferenceTests.Rows()), +}), +}, + methodMetadata: __mm_0, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SpreadMatchingFamilyTupleInferenceTests_Value___Base_T___int__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SpreadMatchingFamilyTupleInferenceTests_Value___Base_T___int__int_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_TupleVariantCandidateTests_Value___IPair_T__object___int__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests)), + Name = "TupleVariantCandidateTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Value", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests), "Value", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests.IPair<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(object))]), new global::TUnit.Core.ConcreteType(typeof(int))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Value((global::TUnit.Core.Helpers.CastHelper.Cast>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Value((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple, int>)(global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast, int>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Value", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests.Value", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 646, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple, int>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple, int>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_TupleVariantCandidateTests_Value___IPair_T__object___int__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_TupleVariantCandidateTests_Value___IPair_T__object___int__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_TupleVariantCandidateTests_Reference__Tuple_IPair_T__object___int__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests)), + Name = "TupleVariantCandidateTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Reference", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests), "Reference", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests.IPair<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(object))]), new global::TUnit.Core.ConcreteType(typeof(int))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.Reference(new global::System.Tuple, int>(global::TUnit.Core.Helpers.CastHelper.Cast>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.Reference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple, int>)new global::System.Tuple, int>(global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast, int>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Reference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests.Reference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 654, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple, int>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple, int>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_TupleVariantCandidateTests_Reference__Tuple_IPair_T__object___int__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_TupleVariantCandidateTests_Reference__Tuple_IPair_T__object___int__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_TupleVariantCandidateTests_ContravariantValue___IConsumer_C2F8F12A_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests)), + Name = "TupleVariantCandidateTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ContravariantValue", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests), "ContravariantValue", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests.IConsumer<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), new global::TUnit.Core.ConcreteType(typeof(int))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.ContravariantValue((global::TUnit.Core.Helpers.CastHelper.Cast>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.ContravariantValue((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple, int>)(global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast, int>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ContravariantValue", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests.ContravariantValue", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 662, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple, int>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple, int>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_TupleVariantCandidateTests_ContravariantValue___IConsumer_C2F8F12A_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_TupleVariantCandidateTests_ContravariantValue___IConsumer_C2F8F12A_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_TupleVariantCandidateTests_ContravariantReference__Tuple__C6BEBFFA_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests)), + Name = "TupleVariantCandidateTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ContravariantReference", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests), "ContravariantReference", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests.IConsumer<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), new global::TUnit.Core.ConcreteType(typeof(int))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.ContravariantReference(new global::System.Tuple, int>(global::TUnit.Core.Helpers.CastHelper.Cast>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.ContravariantReference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple, int>)new global::System.Tuple, int>(global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast, int>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ContravariantReference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests.ContravariantReference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 670, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.TupleVariantCandidateTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple, int>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple, int>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_TupleVariantCandidateTests_ContravariantReference__Tuple__C6BEBFFA_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_TupleVariantCandidateTests_ContravariantReference__Tuple__C6BEBFFA_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_TupleInvariantBaseCandidateTests_Value___IBox_Base_T__obj_291E900C_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests)), + Name = "TupleInvariantBaseCandidateTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Value", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests), "Value", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests.IBox<>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests.Base<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(object))])]), new global::TUnit.Core.ConcreteType(typeof(int))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Value((global::TUnit.Core.Helpers.CastHelper.Cast>>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Value((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple>, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple>, int>)(global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>, int>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Value", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests.Value", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 689, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple>, int>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple>, int>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_TupleInvariantBaseCandidateTests_Value___IBox_Base_T__obj_291E900C_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_TupleInvariantBaseCandidateTests_Value___IBox_Base_T__obj_291E900C_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_TupleInvariantBaseCandidateTests_Reference__Tuple_IBox_Ba_E8C6FC70_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests)), + Name = "TupleInvariantBaseCandidateTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Reference", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests), "Reference", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests.IBox<>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests.Base<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(object))])]), new global::TUnit.Core.ConcreteType(typeof(int))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.Reference(new global::System.Tuple>, int>(global::TUnit.Core.Helpers.CastHelper.Cast>>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.Reference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple>, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple>, int>)new global::System.Tuple>, int>(global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>, int>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Reference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests.Reference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 697, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.TupleInvariantBaseCandidateTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple>, int>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple>, int>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_TupleInvariantBaseCandidateTests_Reference__Tuple_IBox_Ba_E8C6FC70_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_TupleInvariantBaseCandidateTests_Reference__Tuple_IBox_Ba_E8C6FC70_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_TupleConstrainedCandidateTests_Value___IPair_T__IFoo___int__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests)), + Name = "TupleConstrainedCandidateTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Value", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests), "Value", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests.IPair<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests.IFoo))]), new global::TUnit.Core.ConcreteType(typeof(int))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Value((global::TUnit.Core.Helpers.CastHelper.Cast>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Value((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple, int>)(global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast, int>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Value", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests.Value", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 716, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple, int>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple, int>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_TupleConstrainedCandidateTests_Value___IPair_T__IFoo___int__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_TupleConstrainedCandidateTests_Value___IPair_T__IFoo___int__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_TupleConstrainedCandidateTests_Reference__Tuple_IPair_T___9D628D4D_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests)), + Name = "TupleConstrainedCandidateTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Reference", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests), "Reference", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests.IPair<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests.IFoo))]), new global::TUnit.Core.ConcreteType(typeof(int))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.Reference(new global::System.Tuple, int>(global::TUnit.Core.Helpers.CastHelper.Cast>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.Reference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple, int>)new global::System.Tuple, int>(global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast, int>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Reference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests.Reference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 724, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.TupleConstrainedCandidateTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple, int>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple, int>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_TupleConstrainedCandidateTests_Reference__Tuple_IPair_T___9D628D4D_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_TupleConstrainedCandidateTests_Reference__Tuple_IPair_T___9D628D4D_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingletonTupleInferenceTests_ReferenceToValue__ValueTuple_T__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests)), + Name = "SingletonTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceToValue", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests), "ReferenceToValue", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<>), [new global::TUnit.Core.GenericParameter(0, true, "T")]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 1 && args[0] is not global::System.Runtime.CompilerServices.ITuple { Length: 1 }) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.ReferenceToValue(new global::System.ValueTuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.ReferenceToValue((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 1 } __tupleInput0 => (global::System.ValueTuple)new global::System.ValueTuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 1 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ReferenceToValue", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests.ReferenceToValue", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 740, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingletonTupleInferenceTests_ReferenceToValue__ValueTuple_T__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingletonTupleInferenceTests_ReferenceToValue__ValueTuple_T__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingletonTupleInferenceTests_ValueToReference__Tuple_T__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests)), + Name = "SingletonTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueToReference", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests), "ValueToReference", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<>), [new global::TUnit.Core.GenericParameter(0, true, "T")]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 1 && args[0] is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]) is [null]) + { + instance.ValueToReference(new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(null))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + if (args.Length == 1 && args[0] is not null && args[0] is not global::System.Tuple) + { + instance.ValueToReference(new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.ValueToReference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 1 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ValueToReference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests.ValueToReference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 748, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingletonTupleInferenceTests_ValueToReference__Tuple_T__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingletonTupleInferenceTests_ValueToReference__Tuple_T__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_SingletonTupleInferenceTests_ValueToValue__ValueTuple_T__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests)), + Name = "SingletonTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueToValue", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests), "ValueToValue", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<>), [new global::TUnit.Core.GenericParameter(0, true, "T")]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 1 && args[0] is not global::System.Runtime.CompilerServices.ITuple { Length: 1 }) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.ValueToValue(new global::System.ValueTuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.ValueToValue((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 1 } __tupleInput0 => (global::System.ValueTuple)new global::System.ValueTuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 1 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ValueToValue", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests.ValueToValue", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 756, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.SingletonTupleInferenceTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_SingletonTupleInferenceTests_ValueToValue__ValueTuple_T__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_SingletonTupleInferenceTests_ValueToValue__ValueTuple_T__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_Value___T__List_T___TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests)), + Name = "OpenTupleRuntimeCastTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Value", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests), "Value", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Collections.Generic.List<>), [new global::TUnit.Core.GenericParameter(0, true, "T")])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Value((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Value((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple>)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Value", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests.Value", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 774, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_Value___T__List_T___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_Value___T__List_T___TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_Reference__Tuple_T__List_T___TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests)), + Name = "OpenTupleRuntimeCastTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Reference", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests), "Reference", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Collections.Generic.List<>), [new global::TUnit.Core.GenericParameter(0, true, "T")])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.Reference(new global::System.Tuple>(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.Reference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple>)new global::System.Tuple>(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Reference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests.Reference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 782, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_Reference__Tuple_T__List_T___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_Reference__Tuple_T__List_T___TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_Reversed___List_T___T__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests)), + Name = "OpenTupleRuntimeCastTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Reversed", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests), "Reversed", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Collections.Generic.List<>), [new global::TUnit.Core.GenericParameter(0, true, "T")]), new global::TUnit.Core.GenericParameter(0, true, "T")]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Reversed((global::TUnit.Core.Helpers.CastHelper.Cast>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Reversed((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple, int>)(global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast, int>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReversedRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Reversed", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests.Reversed", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 790, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReversedRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests.ReversedRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple, int>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple, int>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_Reversed___List_T___T__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_Reversed___List_T___T__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_Interface___T__List_T___TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests)), + Name = "OpenTupleRuntimeCastTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Interface", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests), "Interface", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Collections.Generic.List<>), [new global::TUnit.Core.GenericParameter(0, true, "T")])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Interface((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Interface((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple>)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("InterfaceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Interface", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests.Interface", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 806, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("InterfaceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests.InterfaceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_Interface___T__List_T___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_Interface___T__List_T___TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_ReferenceInterface__Tuple_T__List_T___TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests)), + Name = "OpenTupleRuntimeCastTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceInterface", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests), "ReferenceInterface", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Collections.Generic.List<>), [new global::TUnit.Core.GenericParameter(0, true, "T")])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.ReferenceInterface(new global::System.Tuple>(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.ReferenceInterface((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple>)new global::System.Tuple>(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceInterfaceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ReferenceInterface", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests.ReferenceInterface", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 810, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceInterfaceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests.ReferenceInterfaceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_ReferenceInterface__Tuple_T__List_T___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_ReferenceInterface__Tuple_T__List_T___TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_ReversedInterface___List_T___T__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests)), + Name = "OpenTupleRuntimeCastTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReversedInterface", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests), "ReversedInterface", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Collections.Generic.List<>), [new global::TUnit.Core.GenericParameter(0, true, "T")]), new global::TUnit.Core.GenericParameter(0, true, "T")]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.ReversedInterface((global::TUnit.Core.Helpers.CastHelper.Cast>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.ReversedInterface((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple, int>)(global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast, int>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReversedInterfaceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ReversedInterface", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests.ReversedInterface", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 814, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReversedInterfaceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests.ReversedInterfaceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple, int>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple, int>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_ReversedInterface___List_T___T__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_ReversedInterface___List_T___T__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_BaseCast___T__Derived_T___TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests)), + Name = "OpenTupleRuntimeCastTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("BaseCast", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests), "BaseCast", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests.Derived<>), [new global::TUnit.Core.GenericParameter(0, true, "T")])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.BaseCast((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.BaseCast((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple>)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("BaseRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "BaseCast", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests.BaseCast", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 818, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("BaseRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.OpenTupleRuntimeCastTests.BaseRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_BaseCast___T__Derived_T___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_OpenTupleRuntimeCastTests_BaseCast___T__Derived_T___TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_WrappedNestedSingletonInferenceTests_ReferenceOuter__Tupl_D6D60BEE_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.WrappedNestedSingletonInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.WrappedNestedSingletonInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.WrappedNestedSingletonInferenceTests)), + Name = "WrappedNestedSingletonInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.WrappedNestedSingletonInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceOuter", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.WrappedNestedSingletonInferenceTests), "ReferenceOuter", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<>), [new global::TUnit.Core.GenericParameter(0, true, "T")])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.WrappedNestedSingletonInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.WrappedNestedSingletonInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.WrappedNestedSingletonInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 1 && args[0] is not global::System.Tuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]) is [null]) + { + instance.ReferenceOuter(new global::System.Tuple>(global::TUnit.Core.Helpers.CastHelper.Cast>(null))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + if (args.Length == 1 && args[0] is not null && args[0] is not global::System.Tuple>) + { + instance.ReferenceOuter(new global::System.Tuple>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 1 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.ReferenceOuter((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 1 } __tupleInput0 => (global::System.Tuple>)new global::System.Tuple>((__tupleInput0[0] switch { var __tupleValue1 when __tupleValue1 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue1) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue1) is { Length: 1 } __tupleInput1 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput1[0])), var __tupleFallback1 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback1) })), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ReferenceOuter", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.WrappedNestedSingletonInferenceTests.ReferenceOuter", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 858, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.WrappedNestedSingletonInferenceTests.Rows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_WrappedNestedSingletonInferenceTests_ReferenceOuter__Tupl_D6D60BEE_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_WrappedNestedSingletonInferenceTests_ReferenceOuter__Tupl_D6D60BEE_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_WrappedNestedSingletonInferenceTests_ValueOuter__ValueTup_05478086_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.WrappedNestedSingletonInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.WrappedNestedSingletonInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.WrappedNestedSingletonInferenceTests)), + Name = "WrappedNestedSingletonInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.WrappedNestedSingletonInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueOuter", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.WrappedNestedSingletonInferenceTests), "ValueOuter", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<>), [new global::TUnit.Core.GenericParameter(0, true, "T")])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.WrappedNestedSingletonInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.WrappedNestedSingletonInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.WrappedNestedSingletonInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 1 && args[0] is not global::System.Runtime.CompilerServices.ITuple { Length: 1 }) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.ValueOuter(new global::System.ValueTuple>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 1 } __tupleInput0 => (global::System.ValueTuple)new global::System.ValueTuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.ValueOuter((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 1 } __tupleInput0 => (global::System.ValueTuple>)new global::System.ValueTuple>((__tupleInput0[0] switch { var __tupleValue1 when __tupleValue1 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue1) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue1) is { Length: 1 } __tupleInput1 => (global::System.ValueTuple)new global::System.ValueTuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput1[0])), var __tupleFallback1 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback1) })), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 1 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ValueOuter", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.WrappedNestedSingletonInferenceTests.ValueOuter", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 866, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.WrappedNestedSingletonInferenceTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_WrappedNestedSingletonInferenceTests_ValueOuter__ValueTup_05478086_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_WrappedNestedSingletonInferenceTests_ValueOuter__ValueTup_05478086_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_WrappedWholeTupleInferenceTests_ValueOptional___T__string__int_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests)), + Name = "WrappedWholeTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueOptional", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests), "ValueOptional", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false) +})); + private static global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.ValueOptional((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (int)(5)); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.ValueOptional((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast(args[1])); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ValueOptional", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests.ValueOptional", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 880, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_WrappedWholeTupleInferenceTests_ValueOptional___T__string__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_WrappedWholeTupleInferenceTests_ValueOptional___T__string__int_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_WrappedWholeTupleInferenceTests_ValueParams___T__string__int___TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests)), + Name = "WrappedWholeTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueParams", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests), "ValueParams", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false) +})); + private static global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::System.Array.Empty()); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + case 3: + { + instance.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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: + if (args.Length < 1) + { + throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}"); + } + instance.ValueParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i]))) : global::System.Array.Empty())); + 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)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ValueParams", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests.ValueParams", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 888, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_WrappedWholeTupleInferenceTests_ValueParams___T__string__int___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_WrappedWholeTupleInferenceTests_ValueParams___T__string__int___TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_WrappedWholeTupleInferenceTests_ValueArray___T__string__int___TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests)), + Name = "WrappedWholeTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueArray", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests), "ValueArray", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false) +})); + private static global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.ValueArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::System.Array.Empty()); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.ValueArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + case 3: + { + instance.ValueArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ValueArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ValueArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ValueArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ValueArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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: + if (args.Length < 1) + { + throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}"); + } + instance.ValueArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i]))) : global::System.Array.Empty())); + 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)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ValueArray", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests.ValueArray", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 896, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_WrappedWholeTupleInferenceTests_ValueArray___T__string__int___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_WrappedWholeTupleInferenceTests_ValueArray___T__string__int___TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_WrappedWholeTupleInferenceTests_ReferenceOptional__Tuple__0307DB81_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests)), + Name = "WrappedWholeTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceOptional", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests), "ReferenceOptional", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false) +})); + private static global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.ReferenceOptional((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (int)(5)); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.ReferenceOptional((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast(args[1])); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ReferenceOptional", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests.ReferenceOptional", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 904, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_WrappedWholeTupleInferenceTests_ReferenceOptional__Tuple__0307DB81_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_WrappedWholeTupleInferenceTests_ReferenceOptional__Tuple__0307DB81_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_WrappedWholeTupleInferenceTests_ReferenceParams__Tuple_T__C1DC6CC5_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests)), + Name = "WrappedWholeTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceParams", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests), "ReferenceParams", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false) +})); + private static global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::System.Array.Empty()); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + case 3: + { + instance.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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: + if (args.Length < 1) + { + throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}"); + } + instance.ReferenceParams((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i]))) : global::System.Array.Empty())); + 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)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ReferenceParams", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests.ReferenceParams", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 912, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_WrappedWholeTupleInferenceTests_ReferenceParams__Tuple_T__C1DC6CC5_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_WrappedWholeTupleInferenceTests_ReferenceParams__Tuple_T__C1DC6CC5_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_WrappedWholeTupleInferenceTests_ReferenceArray__Tuple_T___9BD20EB6_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests)), + Name = "WrappedWholeTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceArray", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests), "ReferenceArray", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false) +})); + private static global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.ReferenceArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::System.Array.Empty()); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.ReferenceArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + case 3: + { + instance.ReferenceArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ReferenceArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ReferenceArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ReferenceArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.ReferenceArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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: + if (args.Length < 1) + { + throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}"); + } + instance.ReferenceArray((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i]))) : global::System.Array.Empty())); + 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)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ReferenceArray", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests.ReferenceArray", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 920, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.WrappedWholeTupleInferenceTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_WrappedWholeTupleInferenceTests_ReferenceArray__Tuple_T___9BD20EB6_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_WrappedWholeTupleInferenceTests_ReferenceArray__Tuple_T___9BD20EB6_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_OpenTupleArrayRuntimeCastTests_Value___T__T____TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests)), + Name = "OpenTupleArrayRuntimeCastTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Value", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests), "Value", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(object))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Value((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Value((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Value", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests.Value", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 940, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_OpenTupleArrayRuntimeCastTests_Value___T__T____TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_OpenTupleArrayRuntimeCastTests_Value___T__T____TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_OpenTupleArrayRuntimeCastTests_Reference__Tuple_T__T____TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests)), + Name = "OpenTupleArrayRuntimeCastTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Reference", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests), "Reference", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(object))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.Reference(new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.Reference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Reference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests.Reference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 944, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_OpenTupleArrayRuntimeCastTests_Reference__Tuple_T__T____TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_OpenTupleArrayRuntimeCastTests_Reference__Tuple_T__T____TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_OpenTupleArrayRuntimeCastTests_Interface___T__T____TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests)), + Name = "OpenTupleArrayRuntimeCastTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Interface", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests), "Interface", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(object))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Interface((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Interface((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("InterfaceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Interface", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests.Interface", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 948, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("InterfaceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests.InterfaceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_OpenTupleArrayRuntimeCastTests_Interface___T__T____TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_OpenTupleArrayRuntimeCastTests_Interface___T__T____TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_OpenTupleArrayRuntimeCastTests_Reversed___T____T__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests)), + Name = "OpenTupleArrayRuntimeCastTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Reversed", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests), "Reversed", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.ConcreteType(typeof(object)), new global::TUnit.Core.GenericParameter(0, true, "T")]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Reversed((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Reversed((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReversedRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Reversed", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests.Reversed", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 952, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReversedRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.OpenTupleArrayRuntimeCastTests.ReversedRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_OpenTupleArrayRuntimeCastTests_Reversed___T____T__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_OpenTupleArrayRuntimeCastTests_Reversed___T____T__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_NestedTupleCandidateBindingTests_Value___T__IBox__U__T____TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests)), + Name = "NestedTupleCandidateBindingTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Value", __classType, typeof(void), __classMetadata, genericTypeCount: 2, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests), "Value", false, 2, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests.IBox<>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(1, true, "U"), new global::TUnit.Core.GenericParameter(0, true, "T")])])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Value((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>>(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Value((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple>> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple>>)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Value", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests.Value", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 976, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple>>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple>>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_NestedTupleCandidateBindingTests_Value___T__IBox__U__T____TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_NestedTupleCandidateBindingTests_Value___T__IBox__U__T____TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_NestedTupleCandidateBindingTests_Reference__Tuple_T__IBox__U__T____TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests)), + Name = "NestedTupleCandidateBindingTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Reference", __classType, typeof(void), __classMetadata, genericTypeCount: 2, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests), "Reference", false, 2, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests.IBox<>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(1, true, "U"), new global::TUnit.Core.GenericParameter(0, true, "T")])])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.Reference(new global::System.Tuple>>(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>>(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.Reference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple>> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple>>)new global::System.Tuple>>(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Reference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests.Reference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 983, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple>>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple>>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_NestedTupleCandidateBindingTests_Reference__Tuple_T__IBox__U__T____TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_NestedTupleCandidateBindingTests_Reference__Tuple_T__IBox__U__T____TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_NestedTupleCandidateBindingTests_NestedValue___T__IBox_Tu_FEB24CC0_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests)), + Name = "NestedTupleCandidateBindingTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("NestedValue", __classType, typeof(void), __classMetadata, genericTypeCount: 2, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests), "NestedValue", false, 2, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests.IBox<>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(1, true, "U"), new global::TUnit.Core.GenericParameter(0, true, "T")])])])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.NestedValue((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>>>(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.NestedValue((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple>>> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple>>>)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast>>>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("NestedValueRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "NestedValue", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests.NestedValue", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 990, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("NestedValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests.NestedValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple>>>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple>>>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_NestedTupleCandidateBindingTests_NestedValue___T__IBox_Tu_FEB24CC0_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_NestedTupleCandidateBindingTests_NestedValue___T__IBox_Tu_FEB24CC0_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_NestedTupleCandidateBindingTests_NestedReference__Tuple_T_CD9482D8_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests)), + Name = "NestedTupleCandidateBindingTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("NestedReference", __classType, typeof(void), __classMetadata, genericTypeCount: 2, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests), "NestedReference", false, 2, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConstructedGeneric(typeof(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests.IBox<>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<>), [new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(1, true, "U"), new global::TUnit.Core.GenericParameter(0, true, "T")])])])]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.NestedReference(new global::System.Tuple>>>(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast>>>(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.NestedReference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple>>> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple>>>)new global::System.Tuple>>>(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast>>>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.MethodDataSourceAttribute("NestedReferenceRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "NestedReference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests.NestedReference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 997, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("NestedReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.NestedTupleCandidateBindingTests.NestedReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple>>>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple>>>)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_NestedTupleCandidateBindingTests_NestedReference__Tuple_T_CD9482D8_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_NestedTupleCandidateBindingTests_NestedReference__Tuple_T_CD9482D8_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_ExplicitWholeTupleInferenceTests_Optional___T__string__int_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests)), + Name = "ExplicitWholeTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Optional", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests), "Optional", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false) +})); + private static global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + switch (methodIndex) + { + case 0: + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.Optional((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (int)(5)); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.Optional((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast(args[1])); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + case 1: + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.Optional((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (int)(5)); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.Optional((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast(args[1])); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + switch (groupIndex) + { + case 0: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + case 1: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex)); + } + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Optional", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests.Optional", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1018, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests.Rows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Optional", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests.Optional", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1018, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests.Rows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 1, + createAttributes: __Attributes_0, + attributeGroupIndex: 1), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_ExplicitWholeTupleInferenceTests_Optional___T__string__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_ExplicitWholeTupleInferenceTests_Optional___T__string__int_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_ExplicitWholeTupleInferenceTests_Params___T__string__int___TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests)), + Name = "ExplicitWholeTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Params", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests), "Params", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false) +})); + private static global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + switch (methodIndex) + { + case 0: + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.Params((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::System.Array.Empty()); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.Params((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + case 3: + { + instance.Params((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.Params((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.Params((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.Params((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.Params((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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: + if (args.Length < 1) + { + throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}"); + } + instance.Params((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i]))) : global::System.Array.Empty())); + 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 1: + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.Params((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::System.Array.Empty()); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.Params((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + case 3: + { + instance.Params((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.Params((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.Params((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.Params((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.Params((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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: + if (args.Length < 1) + { + throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}"); + } + instance.Params((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i]))) : global::System.Array.Empty())); + 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)); + } + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + switch (groupIndex) + { + case 0: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + case 1: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex)); + } + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Params", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests.Params", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1025, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests.Rows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Params", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests.Params", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1025, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests.Rows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 1, + createAttributes: __Attributes_0, + attributeGroupIndex: 1), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_ExplicitWholeTupleInferenceTests_Params___T__string__int___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_ExplicitWholeTupleInferenceTests_Params___T__string__int___TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_ExplicitWholeTupleInferenceTests_Array___T__string__int___TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests)), + Name = "ExplicitWholeTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Array", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests), "Array", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false) +})); + private static global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + switch (methodIndex) + { + case 0: + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.Array((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::System.Array.Empty()); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.Array((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + case 3: + { + instance.Array((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.Array((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.Array((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.Array((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.Array((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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: + if (args.Length < 1) + { + throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}"); + } + instance.Array((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i]))) : global::System.Array.Empty())); + 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 1: + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.Array((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::System.Array.Empty()); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.Array((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + case 3: + { + instance.Array((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.Array((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.Array((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.Array((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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.Array((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), new int[] { 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: + if (args.Length < 1) + { + throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}"); + } + instance.Array((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i]))) : global::System.Array.Empty())); + 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)); + } + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + switch (groupIndex) + { + case 0: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + case 1: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex)); + } + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Array", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests.Array", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1032, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests.Rows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Array", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests.Array", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1032, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests.Rows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 1, + createAttributes: __Attributes_0, + attributeGroupIndex: 1), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_ExplicitWholeTupleInferenceTests_Array___T__string__int___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_ExplicitWholeTupleInferenceTests_Array___T__string__int___TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_ExplicitWholeTupleInferenceTests_Nested___T__string__int_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests)), + Name = "ExplicitWholeTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Nested", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests), "Nested", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false) +})); + private static global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + switch (methodIndex) + { + case 0: + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.Nested((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (int)(5)); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.Nested((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast(args[1])); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + case 1: + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.Nested((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (int)(5)); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.Nested((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast(args[1])); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + switch (groupIndex) + { + case 0: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("NestedRows") + }; + } + case 1: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("NestedRows") + }; + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex)); + } + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Nested", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests.Nested", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1039, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("NestedRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests.NestedRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Nested", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests.Nested", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1039, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("NestedRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitWholeTupleInferenceTests.NestedRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 1, + createAttributes: __Attributes_0, + attributeGroupIndex: 1), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_ExplicitWholeTupleInferenceTests_Nested___T__string__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_ExplicitWholeTupleInferenceTests_Nested___T__string__int_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_ExplicitCrossFamilyTupleInferenceTests_ReferenceToValue___619492FB_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests)), + Name = "ExplicitCrossFamilyTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceToValue", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests), "ReferenceToValue", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + switch (methodIndex) + { + case 0: + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.ReferenceToValue((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.ReferenceToValue((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + case 1: + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.ReferenceToValue((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.ReferenceToValue((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + switch (groupIndex) + { + case 0: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + case 1: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex)); + } + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ReferenceToValue", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests.ReferenceToValue", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1056, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ReferenceToValue", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests.ReferenceToValue", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1056, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 1, + createAttributes: __Attributes_0, + attributeGroupIndex: 1), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_ExplicitCrossFamilyTupleInferenceTests_ReferenceToValue___619492FB_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_ExplicitCrossFamilyTupleInferenceTests_ReferenceToValue___619492FB_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_ExplicitCrossFamilyTupleInferenceTests_ReferenceToReferen_AD6DC901_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests)), + Name = "ExplicitCrossFamilyTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceToReference", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests), "ReferenceToReference", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + switch (methodIndex) + { + case 0: + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.ReferenceToReference(new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.ReferenceToReference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + case 1: + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.ReferenceToReference(new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.ReferenceToReference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + switch (groupIndex) + { + case 0: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + case 1: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex)); + } + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ReferenceToReference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests.ReferenceToReference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1062, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ReferenceToReference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests.ReferenceToReference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1062, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 1, + createAttributes: __Attributes_0, + attributeGroupIndex: 1), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_ExplicitCrossFamilyTupleInferenceTests_ReferenceToReferen_AD6DC901_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_ExplicitCrossFamilyTupleInferenceTests_ReferenceToReferen_AD6DC901_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_ExplicitCrossFamilyTupleInferenceTests_ValueToReference___6C655E71_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests)), + Name = "ExplicitCrossFamilyTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueToReference", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests), "ValueToReference", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + switch (methodIndex) + { + case 0: + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.ValueToReference(new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.ValueToReference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + case 1: + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.ValueToReference(new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.ValueToReference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + switch (groupIndex) + { + case 0: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + case 1: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex)); + } + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ValueToReference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests.ValueToReference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1068, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ValueToReference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests.ValueToReference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1068, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitCrossFamilyTupleInferenceTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 1, + createAttributes: __Attributes_0, + attributeGroupIndex: 1), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_ExplicitCrossFamilyTupleInferenceTests_ValueToReference___6C655E71_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_ExplicitCrossFamilyTupleInferenceTests_ValueToReference___6C655E71_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_ExplicitBareReferenceTupleInferenceTests_WholeRow__T_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.ExplicitBareReferenceTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitBareReferenceTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitBareReferenceTupleInferenceTests)), + Name = "ExplicitBareReferenceTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitBareReferenceTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("WholeRow", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitBareReferenceTupleInferenceTests), "WholeRow", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.GenericParameter(0, true, "T"), false) +})); + private static global::TUnit.TestProject.Bugs._7629.ExplicitBareReferenceTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.ExplicitBareReferenceTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.ExplicitBareReferenceTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.WholeRow>(new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.WholeRow>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(global::System.Tuple)), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "WholeRow>", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitBareReferenceTupleInferenceTests.WholeRow>", + methodTypeArgumentsIdentity: ">", + filePath: "", + lineNumber: 1090, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitBareReferenceTupleInferenceTests.Rows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_ExplicitBareReferenceTupleInferenceTests_WholeRow__T_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_ExplicitBareReferenceTupleInferenceTests_WholeRow__T_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_ExplicitDirectTupleInferenceTests_Value___T__string__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests)), + Name = "ExplicitDirectTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Value", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests), "Value", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + switch (methodIndex) + { + case 0: + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Value((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Value((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + case 1: + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.Value((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.Value((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + switch (groupIndex) + { + case 0: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + case 1: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + }; + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex)); + } + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Value", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests.Value", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1106, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Value", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests.Value", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1106, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ValueRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests.ValueRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 1, + createAttributes: __Attributes_0, + attributeGroupIndex: 1), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_ExplicitDirectTupleInferenceTests_Value___T__string__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_ExplicitDirectTupleInferenceTests_Value___T__string__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_ExplicitDirectTupleInferenceTests_Reference__Tuple_T__string__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests)), + Name = "ExplicitDirectTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Reference", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests), "Reference", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + switch (methodIndex) + { + case 0: + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.Reference(new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.Reference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + case 1: + { + try + { + // Special handling for single reference tuple parameter + if (args.Length == 2) + { + instance.Reference(new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.Reference((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + switch (groupIndex) + { + case 0: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + case 1: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex)); + } + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Reference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests.Reference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1109, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Reference", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests.Reference", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1109, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 1, + createAttributes: __Attributes_0, + attributeGroupIndex: 1), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_ExplicitDirectTupleInferenceTests_Reference__Tuple_T__string__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_ExplicitDirectTupleInferenceTests_Reference__Tuple_T__string__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_ExplicitDirectTupleInferenceTests_ReferenceToValue___T__string__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests)), + Name = "ExplicitDirectTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceToValue", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests), "ReferenceToValue", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false) +})); + private static global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + switch (methodIndex) + { + case 0: + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.ReferenceToValue((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.ReferenceToValue((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + case 1: + { + try + { + // Special handling for single tuple parameter + if (args.Length == 2) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.ReferenceToValue((global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.ReferenceToValue((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + switch (groupIndex) + { + case 0: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + case 1: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + }; + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex)); + } + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ReferenceToValue", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests.ReferenceToValue", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1112, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + global::TUnit.Core.TestEntryFactory.Create( + methodName: "ReferenceToValue", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests.ReferenceToValue", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1112, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitDirectTupleInferenceTests.ReferenceRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 1, + createAttributes: __Attributes_0, + attributeGroupIndex: 1), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_ExplicitDirectTupleInferenceTests_ReferenceToValue___T__string__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_ExplicitDirectTupleInferenceTests_ReferenceToValue___T__string__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_ExplicitWrappedTupleInferenceTests_Direct___T__string__int_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests)), + Name = "ExplicitWrappedTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Direct", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests), "Direct", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false) +})); + private static global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + switch (methodIndex) + { + case 0: + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.Direct((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (int)(5)); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.Direct((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast(args[1])); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + case 1: + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.Direct((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (int)(5)); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.Direct((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast(args[1])); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + switch (groupIndex) + { + case 0: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + case 1: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + }; + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex)); + } + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Direct", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests.Direct", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1132, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests.Rows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Direct", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests.Direct", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1132, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests.Rows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 1, + createAttributes: __Attributes_0, + attributeGroupIndex: 1), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_ExplicitWrappedTupleInferenceTests_Direct___T__string__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_ExplicitWrappedTupleInferenceTests_Direct___T__string__int_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_ExplicitWrappedTupleInferenceTests_Inner___T__string__int_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests)), + Name = "ExplicitWrappedTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Inner", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests), "Inner", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false) +})); + private static global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + switch (methodIndex) + { + case 0: + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.Inner((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (int)(5)); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.Inner((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast(args[1])); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + case 1: + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.Inner((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (int)(5)); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.Inner((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast(args[1])); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + switch (groupIndex) + { + case 0: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("InnerRows") + }; + } + case 1: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("InnerRows") + }; + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex)); + } + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Inner", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests.Inner", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1135, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("InnerRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests.InnerRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Inner", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests.Inner", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1135, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("InnerRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests.InnerRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 1, + createAttributes: __Attributes_0, + attributeGroupIndex: 1), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_ExplicitWrappedTupleInferenceTests_Inner___T__string__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_ExplicitWrappedTupleInferenceTests_Inner___T__string__int_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_ExplicitWrappedTupleInferenceTests_Outer___T__string__int_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests)), + Name = "ExplicitWrappedTupleInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Outer", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests), "Outer", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false) +})); + private static global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + switch (methodIndex) + { + case 0: + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.Outer((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (int)(5)); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.Outer((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast(args[1])); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + case 1: + { + try + { + if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]); + args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleElements[1])) }; + } + switch (args.Length) + { + case 1: + { + instance.Outer((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), (int)(5)); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.Outer((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple)(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast(args[1])); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}"); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + switch (groupIndex) + { + case 0: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("OuterRows") + }; + } + case 1: + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("OuterRows") + }; + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex)); + } + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Outer", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests.Outer", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1138, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("OuterRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests.OuterRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Outer", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests.Outer", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1138, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("OuterRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitWrappedTupleInferenceTests.OuterRows()), + }, +}, + methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } }, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 1, + createAttributes: __Attributes_0, + attributeGroupIndex: 1), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_ExplicitWrappedTupleInferenceTests_Outer___T__string__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_ExplicitWrappedTupleInferenceTests_Outer___T__string__int_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_ExplicitSpreadColumnInferenceTests_Array__T_T___TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.ExplicitSpreadColumnInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitSpreadColumnInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitSpreadColumnInferenceTests)), + Name = "ExplicitSpreadColumnInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitSpreadColumnInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Array", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitSpreadColumnInferenceTests), "Array", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "first", new global::TUnit.Core.GenericParameter(0, true, "T"), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "extra", new global::TUnit.Core.ConcreteType(typeof(object)), false) +})); + private static global::TUnit.TestProject.Bugs._7629.ExplicitSpreadColumnInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.ExplicitSpreadColumnInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.ExplicitSpreadColumnInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + switch (args.Length) + { + case 1: + { + instance.Array(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::System.Array.Empty()); + return default(global::System.Threading.Tasks.ValueTask); + } + case 2: + { + instance.Array(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), (args[1] is null ? null : args[1] is long[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray(args[1]))); + return default(global::System.Threading.Tasks.ValueTask); + } + case 3: + { + instance.Array(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), new long[] { 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.Array(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), new long[] { 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.Array(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), new long[] { 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.Array(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), new long[] { 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.Array(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), new long[] { 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: + if (args.Length < 1) + { + throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}"); + } + instance.Array(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast(args[i]))) : global::System.Array.Empty())); + 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)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("ArrayRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Array", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitSpreadColumnInferenceTests.Array", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1156, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("ArrayRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitSpreadColumnInferenceTests.ArrayRows()), + }, +}, + methodMetadata: __mm_0, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_ExplicitSpreadColumnInferenceTests_Array__T_T___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_ExplicitSpreadColumnInferenceTests_Array__T_T___TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_ExplicitSpreadColumnInferenceTests_Nullable__T_T__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.ExplicitSpreadColumnInferenceTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitSpreadColumnInferenceTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitSpreadColumnInferenceTests)), + Name = "ExplicitSpreadColumnInferenceTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.ExplicitSpreadColumnInferenceTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Nullable", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7629.ExplicitSpreadColumnInferenceTests), "Nullable", false, 1, new global::TUnit.Core.ParameterMetadata[] +{ +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "first", new global::TUnit.Core.GenericParameter(0, true, "T"), false), +global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "extra", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Nullable<>), [new global::TUnit.Core.GenericParameter(0, true, "T")]), true) +})); + private static global::TUnit.TestProject.Bugs._7629.ExplicitSpreadColumnInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.ExplicitSpreadColumnInferenceTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7629.ExplicitSpreadColumnInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + instance.Nullable(global::TUnit.Core.Helpers.CastHelper.Cast(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast(args[1])); + 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)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)), + new global::TUnit.Core.MethodDataSourceAttribute("NullableRows") + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "Nullable", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.ExplicitSpreadColumnInferenceTests.Nullable", + methodTypeArgumentsIdentity: "", + filePath: "", + lineNumber: 1163, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("NullableRows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.ExplicitSpreadColumnInferenceTests.NullableRows()), + }, +}, + methodMetadata: __mm_0, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_ExplicitSpreadColumnInferenceTests_Nullable__T_T__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_ExplicitSpreadColumnInferenceTests_Nullable__T_T__TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_Bugs__7629_NestedSingletonBoundaryTests__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7629.NestedSingletonBoundaryTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.Bugs._7629.NestedSingletonBoundaryTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7629.NestedSingletonBoundaryTests)), + Name = "NestedSingletonBoundaryTests", + Namespace = "TUnit.TestProject.Bugs._7629", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7629.NestedSingletonBoundaryTests); + private static global::TUnit.TestProject.Bugs._7629.NestedSingletonBoundaryTests __CreateInstance(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.Bugs._7629.NestedSingletonBoundaryTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke(global::TUnit.TestProject.Bugs._7629.NestedSingletonBoundaryTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + switch (methodIndex) + { + case 0: + { + // Special handling for single reference tuple parameter + if (args.Length == 1 && args[0] is not global::System.Tuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]) is [null]) + { + instance.ReferenceOuter(new global::System.Tuple>(global::TUnit.Core.Helpers.CastHelper.Cast>(null))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + if (args.Length == 1 && args[0] is not null && args[0] is not global::System.Tuple>) + { + instance.ReferenceOuter(new global::System.Tuple>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 1 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }))); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + switch (args.Length) + { + case 1: + { + instance.ReferenceOuter((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 1 } __tupleInput0 => (global::System.Tuple>)new global::System.Tuple>((__tupleInput0[0] switch { var __tupleValue1 when __tupleValue1 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue1) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue1) is { Length: 1 } __tupleInput1 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput1[0])), var __tupleFallback1 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback1) })), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + default: + throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}"); + } + } + } + case 1: + { + // Special handling for single tuple parameter + if (args.Length == 1 && args[0] is not global::System.Runtime.CompilerServices.ITuple { Length: 1 }) + { + // Arguments are unwrapped tuple elements, reconstruct the tuple + instance.ValueOuter(new global::System.ValueTuple>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 1 } __tupleInput0 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput0[0])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback0) }))); + return default(global::System.Threading.Tasks.ValueTask); + } + else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0])) + { + // Rare case: tuple is wrapped as a single argument + instance.ValueOuter((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 1 } __tupleInput0 => (global::System.ValueTuple>)new global::System.ValueTuple>((__tupleInput0[0] switch { var __tupleValue1 when __tupleValue1 is not global::System.Tuple && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue1) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue1) is { Length: 1 } __tupleInput1 => (global::System.Tuple)new global::System.Tuple(global::TUnit.Core.Helpers.CastHelper.Cast(__tupleInput1[0])), var __tupleFallback1 => global::TUnit.Core.Helpers.CastHelper.Cast>(__tupleFallback1) })), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast>>(__tupleFallback0) })); + return default(global::System.Threading.Tasks.ValueTask); + } + else + { + throw new global::System.ArgumentException($"Expected 1 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments"); + } + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex)); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes(int groupIndex) + { + switch (groupIndex) + { + case 0: + { + return + [ + new global::TUnit.Core.TestAttribute() + ]; + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex)); + } + } + private static readonly global::System.Func __createInstance = __CreateInstance; + private static readonly global::System.Func __invoke = __Invoke; + private static readonly global::System.Func __attributes = __Attributes; + public static readonly global::TUnit.Core.TestEntry[] Entries = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.CreateWithClassMetadata( + methodName: "ReferenceOuter", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.NestedSingletonBoundaryTests.ReferenceOuter", + filePath: "", + lineNumber: 834, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.NestedSingletonBoundaryTests.Rows()), + }, +}, + parameters: global::TUnit.Core.ParameterMetadataFactory.ForMethod(typeof(global::TUnit.TestProject.Bugs._7629.NestedSingletonBoundaryTests), "ReferenceOuter", false, new global::TUnit.Core.ParameterMetadata[] + { + global::TUnit.Core.ParameterMetadataFactory.Create(typeof(global::System.Tuple>), "row", new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple>)), false) + }), + classMetadata: __classMetadata, + createInstance: __createInstance, + invokeBody: __invoke, + methodIndex: 0, + createAttributes: __attributes, + attributeGroupIndex: 0), + global::TUnit.Core.TestEntryFactory.CreateWithClassMetadata( + methodName: "ValueOuter", + fullyQualifiedName: "TUnit.TestProject.Bugs._7629.NestedSingletonBoundaryTests.ValueOuter", + filePath: "", + lineNumber: 842, + hasDataSource: true, + testDataSources: new global::TUnit.Core.IDataSourceAttribute[] +{ + new global::TUnit.Core.MethodDataSourceAttribute("Rows") + { + Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7629.NestedSingletonBoundaryTests.Rows()), + }, +}, + parameters: global::TUnit.Core.ParameterMetadataFactory.ForMethod(typeof(global::TUnit.TestProject.Bugs._7629.NestedSingletonBoundaryTests), "ValueOuter", false, new global::TUnit.Core.ParameterMetadata[] + { + global::TUnit.Core.ParameterMetadataFactory.Create(typeof(global::System.ValueTuple>), "row", new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple>)), false) + }), + classMetadata: __classMetadata, + createInstance: __createInstance, + invokeBody: __invoke, + methodIndex: 1, + createAttributes: __attributes, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_Bugs__7629_NestedSingletonBoundaryTests__TestSource = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_Bugs__7629_NestedSingletonBoundaryTests__TestSource.Entries); +} diff --git a/tests/TUnit.Core.SourceGenerator.Tests/TupleInferenceTests.cs b/tests/TUnit.Core.SourceGenerator.Tests/TupleInferenceTests.cs new file mode 100644 index 00000000000..d05bbcaa630 --- /dev/null +++ b/tests/TUnit.Core.SourceGenerator.Tests/TupleInferenceTests.cs @@ -0,0 +1,8 @@ +namespace TUnit.Core.SourceGenerator.Tests; + +internal class TupleInferenceTests : TestsBase +{ + [Test] + public Task Test() => RunTest(Path.Combine(Git.TestsDirectory.FullName, + "TUnit.TestProject", "Bugs", "_7629", "TupleInferenceTests.cs"), _ => Task.CompletedTask); +} diff --git a/tests/TUnit.Engine.Tests/Issue7629Tests.cs b/tests/TUnit.Engine.Tests/Issue7629Tests.cs new file mode 100644 index 00000000000..7991baec656 --- /dev/null +++ b/tests/TUnit.Engine.Tests/Issue7629Tests.cs @@ -0,0 +1,90 @@ +using Shouldly; +using TUnit.Engine.Tests.Enums; + +namespace TUnit.Engine.Tests; + +public class Issue7629Tests(TestMode testMode) : InvokableTestBase(testMode) +{ + [Test] + [Arguments("NestedTupleWithTrailingParametersTests", 4)] + [Arguments("ClosedNestedTupleConversionTests", 1)] + [Arguments("RepeatedTupleBindingTests", 3)] + [Arguments("RepeatedConvertibleTupleTests", 2)] + [Arguments("RepeatedNullableTupleTests", 6)] + [Arguments("RepeatedNestedGenericTupleTests", 3)] + [Arguments("OpenTupleAssignabilityTests", 3)] + [Arguments("SingleTupleElementConversionTests", 18)] + [Arguments("BoxedTupleElementConversionTests", 2)] + [Arguments("WholeReferenceTupleSourceTests", 1)] + [Arguments("InferredReferenceTupleSourceTests", 1)] + [Arguments("TupleInterfaceCandidateIsolationTests", 2)] + [Arguments("NestedTupleCandidateBindingTests", 4)] + [Arguments("TupleNestedInterfaceBaseTests", 2)] + [Arguments("TupleMultiParameterCandidateTests", 2)] + [Arguments("TupleClosedCandidateArgumentTests", 2)] + [Arguments("TupleVariantCandidateTests", 4)] + [Arguments("TupleInvariantBaseCandidateTests", 2)] + [Arguments("TupleConstrainedCandidateTests", 2)] + [Arguments("NestedSingletonBoundaryTests", 2)] + [Arguments("WrappedNestedSingletonInferenceTests", 2)] + [Arguments("WrappedWholeTupleInferenceTests", 6)] + [Arguments("SingletonTupleInferenceTests", 3)] + [Arguments("OpenTupleRuntimeCastTests", 7)] + [Arguments("OpenTupleArrayRuntimeCastTests", 4)] + [Arguments("WholeTupleWithTrailingParametersTests", 6)] + [Arguments("ExplicitSpreadColumnInferenceTests", 2)] + [Arguments("ExplicitDirectTupleInferenceTests", 6)] + [Arguments("ExplicitCrossFamilyTupleInferenceTests", 6)] + [Arguments("ExplicitBareReferenceTupleInferenceTests", 1)] + public async Task Tuple_Inference_And_Conversion_Agree_In_Both_Modes(string className, int expectedCount) + { + await RunTestsWithFilter( + $"/*/TUnit.TestProject.Bugs._7629/{className}/*", + [ + result => result.ResultSummary.Counters.Total.ShouldBe(expectedCount), + result => result.ResultSummary.Counters.Passed.ShouldBe(expectedCount), + result => result.ResultSummary.Counters.Failed.ShouldBe(0) + ]); + } + + [Test] + public async Task Explicit_Wrapped_Rows_Still_Infer_Whole_Tuples() + { + await RunTestsWithFilter( + "/*/TUnit.TestProject.Bugs._7629/ExplicitWrappedTupleInferenceTests/*", + [ + result => result.ResultSummary.Counters.Total.ShouldBe(6), + result => result.ResultSummary.Counters.Passed.ShouldBe(3), + // Explicit long cannot receive an int tuple with an optional tail. + result => result.ResultSummary.Counters.Failed.ShouldBe(3) + ]); + } + + [Test] + public async Task Explicit_Method_Types_Still_Infer_Whole_Tuple_Rows() + { + await RunTestsWithFilter( + "/*/TUnit.TestProject.Bugs._7629/ExplicitWholeTupleInferenceTests/*", + [ + result => result.ResultSummary.Counters.Total.ShouldBe(8), + result => result.ResultSummary.Counters.Passed.ShouldBe(5), + // The three explicit long instantiations cannot receive the whole (int, string) + // row with a trailing parameter. Only the inferred int instantiations match. + result => result.ResultSummary.Counters.Failed.ShouldBe(3) + ]); + } + + [Test] + [Arguments("OrdinaryGenericBaseInferenceTests")] + [Arguments("SpreadCrossFamilyTupleInferenceTests")] + [Arguments("SpreadMatchingFamilyTupleInferenceTests")] + public async Task Unsupported_Inference_Remains_Consistent_In_Both_Modes(string className) + { + await RunTestsWithFilter( + $"/*/TUnit.TestProject.Bugs._7629/{className}/*", + [ + result => result.ResultSummary.Counters.Total.ShouldBe(1), + result => result.ResultSummary.Counters.Failed.ShouldBe(1) + ]); + } +} diff --git a/tests/TUnit.TestProject/Bugs/_7629/TupleInferenceTests.cs b/tests/TUnit.TestProject/Bugs/_7629/TupleInferenceTests.cs new file mode 100644 index 00000000000..2e632c94fd3 --- /dev/null +++ b/tests/TUnit.TestProject/Bugs/_7629/TupleInferenceTests.cs @@ -0,0 +1,1171 @@ +namespace TUnit.TestProject.Bugs._7629; + +public class NestedTupleWithTrailingParametersTests +{ + public static IEnumerable<((int, string), int)> ValueRows() => [((1, "tuple"), 7)]; + public static IEnumerable, int>> ReferenceRows() => [Tuple.Create(Tuple.Create(1, "tuple"), 7)]; + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void ValueOptional((T, string) row, int extra = 5) where T : struct + { + if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra != 7) + throw new InvalidOperationException("Expected nested tuple and supplied column"); + } + + public static IEnumerable<((int, string), int[])> ValueParamsRows() => [((1, "tuple"), [7])]; + + [Test] + [MethodDataSource(nameof(ValueParamsRows))] + public void ValueParams((T, string) row, params int[] extra) where T : struct + { + if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra is not [7]) + throw new InvalidOperationException("Expected nested tuple and supplied params column"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void ReferenceOptional(Tuple row, int extra = 5) where T : struct + { + if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra != 7) + throw new InvalidOperationException("Expected nested tuple and supplied column"); + } + + public static IEnumerable, int[]>> ReferenceParamsRows() => [Tuple.Create(Tuple.Create(1, "tuple"), new[] { 7 })]; + + [Test] + [MethodDataSource(nameof(ReferenceParamsRows))] + public void ReferenceParams(Tuple row, params int[] extra) where T : struct + { + if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra is not [7]) + throw new InvalidOperationException("Expected nested tuple and supplied params column"); + } +} + + +public class ClosedNestedTupleConversionTests +{ + public static IEnumerable<((int, (object, int)), (int, int))> Rows() => [((1, (new object(), 2)), (3, 4))]; + + [Test] + [MethodDataSource(nameof(Rows))] + public void ClosedNested((T, (object, int)) pair, (int, int)? extra = null) + { + if (typeof(T) != typeof(int) || pair.Item2.Item2 != 2 || extra != (3, 4)) + throw new InvalidOperationException("Expected separate columns with a closed nested tuple"); + } +} + +public class RepeatedTupleBindingTests +{ + public static IEnumerable<((string, string), int)> ValueRows() => [(("a", "b"), 7)]; + public static IEnumerable, Tuple>> ReferenceRows() => + [Tuple.Create(Tuple.Create(1, 2), Tuple.Create(7, "extra"))]; + public static IEnumerable<(int, int)> WholeRows() => [(1, 2)]; + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void RepeatedValue((T, T) row, int extra = 0) + { + if (typeof(T) != typeof(string) || extra != 7) + throw new InvalidOperationException("Expected consistent string binding and separate extra column"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void RepeatedReference(Tuple row, Tuple? extra = null) + { + if (typeof(T) != typeof(int) || extra?.Item2 != "extra") + throw new InvalidOperationException("Expected consistent int binding and separate extra column"); + } + + [Test] + [MethodDataSource(nameof(WholeRows))] + public void RepeatedWhole((T, T) row) + { + if (typeof(T) != typeof(int)) + throw new InvalidOperationException("Expected consistent whole-row int binding"); + } +} + +public class OpenTupleAssignabilityTests +{ + public static IEnumerable<((int, object), string)> ValueRows() => [((1, new object()), "extra")]; + public static IEnumerable, string>> ReferenceRows() => + [Tuple.Create(Tuple.Create(1, new object()), "extra")]; + public static IEnumerable> CrossFamilyRows() => [Tuple.Create(1, "tuple")]; + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void ValueAssignable((T, object) row, string extra = "") + { + if (typeof(T) != typeof(int) || extra != "extra") + throw new InvalidOperationException("Expected separate columns and int inference"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void ReferenceAssignable(Tuple row, string extra = "") + { + if (typeof(T) != typeof(int) || extra != "extra") + throw new InvalidOperationException("Expected separate columns and int inference"); + } + + [Test] + // TUnit0001 currently spreads a reference tuple before matching an open value-tuple parameter. +#pragma warning disable TUnit0001 + [MethodDataSource(nameof(CrossFamilyRows))] +#pragma warning restore TUnit0001 + public void CrossFamily((T, string) row) + { + if (typeof(T) != typeof(int) || row.Item2 != "tuple") + throw new InvalidOperationException("Expected logical tuple element inference"); + } +} + +public class SingleTupleElementConversionTests +{ + public static IEnumerable<(int, int)> Rows() => [(1, 2)]; + + public static IEnumerable> NarrowReferenceRows() => [Tuple.Create(3, 4)]; + + [Test] + [MethodDataSource(nameof(Rows))] + public void NarrowNumericElement((T, short) row) + { + if (typeof(T) != typeof(int) || row.Item2 != 2) + throw new InvalidOperationException("Expected narrowing numeric element conversion"); + } + + [Test] + [MethodDataSource(nameof(NarrowReferenceRows))] + public void NarrowNumericReferenceElement(Tuple row) + { + if (typeof(T) != typeof(int) || row.Item2 != 4) + throw new InvalidOperationException("Expected narrowing numeric reference element conversion"); + } + + [Test] + [MethodDataSource(nameof(Rows))] + public void EnumElement((T, DayOfWeek) row) + { + if (typeof(T) != typeof(int) || row.Item2 != DayOfWeek.Tuesday) + throw new InvalidOperationException("Expected integral-to-enum element conversion"); + } + + [Test] + [MethodDataSource(nameof(NarrowReferenceRows))] + public void EnumReferenceElement(Tuple row) + { + if (typeof(T) != typeof(int) || row.Item2 != DayOfWeek.Thursday) + throw new InvalidOperationException("Expected integral-to-enum reference element conversion"); + } + + public static IEnumerable<(int, bool)> ConvertibleRows() => [(1, true)]; + public static IEnumerable> ConvertibleReferenceRows() => [Tuple.Create(2, 1)]; + + [Test] + [MethodDataSource(nameof(ConvertibleRows))] + public void ConvertibleElement((T, int) row) + { + if (typeof(T) != typeof(int) || row.Item2 != 1) + throw new InvalidOperationException("Expected IConvertible element conversion"); + } + + [Test] + [MethodDataSource(nameof(ConvertibleReferenceRows))] + public void ConvertibleReferenceElement(Tuple row) + { + if (typeof(T) != typeof(int) || row.Item2 != true) + throw new InvalidOperationException("Expected nullable IConvertible reference element conversion"); + } + + public static IEnumerable<(int, string)> StringRows() => [(1, "2")]; + public static IEnumerable> StringReferenceRows() => [Tuple.Create(3, "4.5")]; + + [Test] + [MethodDataSource(nameof(StringRows))] + public void StringElement((T, int) row) + { + if (typeof(T) != typeof(int) || row.Item2 != 2) + throw new InvalidOperationException("Expected parsed string element conversion"); + } + + [Test] + [MethodDataSource(nameof(StringReferenceRows))] + public void StringReferenceElement(Tuple row) + { + if (typeof(T) != typeof(int) || row.Item2 != 4.5m) + throw new InvalidOperationException("Expected parsed nullable string reference element conversion"); + } + + public class Source + { + public int Value { get; init; } + public static implicit operator Destination(Source source) => new() { Value = source.Value }; + } + + public class Destination { public int Value { get; init; } } + public static IEnumerable<(int, Source)> OperatorRows() => [(1, new Source { Value = 9 })]; + public static IEnumerable> OperatorReferenceRows() => [Tuple.Create(2, new Source { Value = 10 })]; + + [Test] + [MethodDataSource(nameof(OperatorRows))] + public void OperatorElement((T, Destination) row) + { + if (typeof(T) != typeof(int) || row.Item2.Value != 9) + throw new InvalidOperationException("Expected user-defined element conversion"); + } + + [Test] + [MethodDataSource(nameof(OperatorReferenceRows))] + public void OperatorReferenceElement(Tuple row) + { + if (typeof(T) != typeof(int) || row.Item2.Value != 10) + throw new InvalidOperationException("Expected user-defined reference element conversion"); + } + + public class Base { } + public class Derived : Base { } + + public static IEnumerable<(Derived, int)> BaseRows() => [(new Derived(), 7)]; + public static IEnumerable> BaseReferenceRows() => [Tuple.Create(new Derived(), 8)]; + + [Test] + [MethodDataSource(nameof(BaseRows))] + public void BaseElement((Base, T) row) + { + if (typeof(T) != typeof(int) || row.Item1 is not Derived || !Equals(row.Item2, 7)) + throw new InvalidOperationException("Expected generic base-class element conversion"); + } + + [Test] + [MethodDataSource(nameof(BaseReferenceRows))] + public void BaseReferenceElement(Tuple, T> row) + { + if (typeof(T) != typeof(int) || row.Item1 is not Derived || !Equals(row.Item2, 8)) + throw new InvalidOperationException("Expected generic base-class reference element conversion"); + } + + public static IEnumerable<(int[], int)> InterfaceRows() => [(new[] { 5 }, 5)]; + public static IEnumerable, int>> InterfaceReferenceRows() => [Tuple.Create(new List { 6 }, 6)]; + + [Test] + [MethodDataSource(nameof(InterfaceRows))] + public void InterfaceElement((IEnumerable, T) row) + { + if (typeof(T) != typeof(int) || !row.Item1.SequenceEqual(new[] { row.Item2 })) + throw new InvalidOperationException("Expected generic interface element conversion"); + } + + [Test] + [MethodDataSource(nameof(InterfaceReferenceRows))] + public void InterfaceReferenceElement(Tuple, T> row) + { + if (typeof(T) != typeof(int) || !row.Item1.SequenceEqual(new[] { row.Item2 })) + throw new InvalidOperationException("Expected generic interface reference element conversion"); + } + + [Test] + [MethodDataSource(nameof(Rows))] + public void NullableElement((T, int?) row) + { + if (typeof(T) != typeof(int) || row.Item2 != 2) + throw new InvalidOperationException("Expected nullable element conversion"); + } + + public static IEnumerable<(int, string)> OpenNullableRows() => [(3, "nullable")]; + public static IEnumerable> OpenNullableReferenceRows() => [Tuple.Create(4, "nullable")]; + + [Test] + [MethodDataSource(nameof(OpenNullableRows))] + public void OpenNullableElement((T?, string) row) where T : struct + { + if (typeof(T) != typeof(int) || row.Item1 is not int value || value != 3 || row.Item2 != "nullable") + throw new InvalidOperationException("Expected open nullable element inference"); + } + + [Test] + [MethodDataSource(nameof(OpenNullableReferenceRows))] + public void OpenNullableReferenceElement(Tuple row) where T : struct + { + if (typeof(T) != typeof(int) || row.Item1 is not int value || value != 4 || row.Item2 != "nullable") + throw new InvalidOperationException("Expected open nullable reference element inference"); + } + + [Test] + [MethodDataSource(nameof(Rows))] + public void NumericElement((T, long) row) + { + if (typeof(T) != typeof(int) || row.Item2 != 2) + throw new InvalidOperationException("Expected numeric element conversion"); + } +} + + +public class BoxedTupleElementConversionTests +{ + public static IEnumerable<(int, object)> ValueRows() => [(1, (object)2)]; + public static IEnumerable> ReferenceRows() => [Tuple.Create(3, (object)4)]; + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void Value((T, int) row) + { + if (typeof(T) != typeof(int) || !Equals(row.Item1, 1) || row.Item2 != 2) + throw new InvalidOperationException("Expected boxed closed element conversion and int inference"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void Reference(Tuple row) + { + if (typeof(T) != typeof(int) || !Equals(row.Item1, 3) || row.Item2 != 4) + throw new InvalidOperationException("Expected boxed reference element conversion and int inference"); + } +} + +public class WholeReferenceTupleSourceTests +{ + public static IEnumerable> Rows() => [Tuple.Create(1, "tuple")]; + + [Test] + [GenerateGenericTest(typeof(Tuple))] +#pragma warning disable TUnit0001 // #7622: analyzer does not substitute explicit generic types before spreading. + [MethodDataSource(nameof(Rows))] +#pragma warning restore TUnit0001 + public void WholeRow(T row) + { + if (row is not Tuple { Item1: 1, Item2: "tuple" }) + throw new InvalidOperationException("Expected the whole reference tuple exactly once"); + } +} + +public class InferredReferenceTupleSourceTests +{ + public static IEnumerable> Rows() => [Tuple.Create(2)]; + + [Test] + [MethodDataSource(nameof(Rows))] + public void Element(T value) where T : struct + { + if (typeof(T) != typeof(int) || !Equals(value, 2)) + throw new InvalidOperationException("Expected first reference-tuple element"); + } +} + +public class TupleInterfaceCandidateIsolationTests +{ + public sealed class DualEnumerable : IEnumerable, IEnumerable + { + IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable)new[] { 1 }).GetEnumerator(); + IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable)new[] { "value" }).GetEnumerator(); + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => ((IEnumerable)this).GetEnumerator(); + } + + public static IEnumerable<(string, DualEnumerable)> ValueRows() => [("value", new DualEnumerable())]; + public static IEnumerable> ReferenceRows() => [Tuple.Create("value", new DualEnumerable())]; + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void Value((T, IEnumerable) row) + { + if (typeof(T) != typeof(string) || !row.Item2.SequenceEqual(new[] { row.Item1 })) + throw new InvalidOperationException("Expected rejected interface candidates to leave string binding intact"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void Reference(Tuple> row) + { + if (typeof(T) != typeof(string) || !row.Item2.SequenceEqual(new[] { row.Item1 })) + throw new InvalidOperationException("Expected rejected reference interface candidates to leave string binding intact"); + } +} + +// #7622: analyzer whole-reference-tuple matching is tracked separately. +#pragma warning disable TUnit0001 +public class WholeTupleWithTrailingParametersTests +{ + public static IEnumerable<(int, string)> ValueRows() => [(1, "tuple")]; + public static IEnumerable> ReferenceRows() => [Tuple.Create(1, "tuple")]; + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void ValueOptional((T, string) row, int extra = 5) + { + if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra != 5) + throw new InvalidOperationException("Expected whole value tuple and default optional value"); + } + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void ValueParams((T, string) row, params int[] extra) + { + if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra.Length != 0) + throw new InvalidOperationException("Expected whole value tuple and empty params"); + } + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void ValueArray((T, string) row, int[] extra) + { + if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra.Length != 0) + throw new InvalidOperationException("Expected whole value tuple and empty collecting array"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void ReferenceOptional(Tuple row, int extra = 5) + { + if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra != 5) + throw new InvalidOperationException("Expected whole reference tuple and default optional value"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void ReferenceParams(Tuple row, params int[] extra) + { + if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra.Length != 0) + throw new InvalidOperationException("Expected whole reference tuple and empty params"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void ReferenceArray(Tuple row, int[] extra) + { + if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra.Length != 0) + throw new InvalidOperationException("Expected whole reference tuple and empty collecting array"); + } +} +#pragma warning restore TUnit0001 + +public class RepeatedConvertibleTupleTests +{ + public static IEnumerable<(int, long)> ValueRows() => [(1, 2L)]; + public static IEnumerable> ReferenceRows() => [Tuple.Create(3, 4L)]; + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void Value((T, T) row) + { + if (typeof(T) != typeof(long) || !Equals(row.Item1, 1L) || !Equals(row.Item2, 2L)) + throw new InvalidOperationException("Expected long inference and converted first element"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void Reference(Tuple row) + { + if (typeof(T) != typeof(long) || !Equals(row.Item1, 3L) || !Equals(row.Item2, 4L)) + throw new InvalidOperationException("Expected long inference and converted reference elements"); + } +} + +public class RepeatedNullableTupleTests +{ + public static IEnumerable<(int, long)> ValueRows() => [(1, 2L)]; + public static IEnumerable<(int, long?)> NullableRows() => [(1, 2L), (1, null)]; + public static IEnumerable> ReferenceRows() => [Tuple.Create(3, 4L)]; + public static IEnumerable> NullableReferenceRows() => + [Tuple.Create(3, 4L), Tuple.Create(3, null)]; + + [Test] + [MethodDataSource(nameof(ValueRows))] + [MethodDataSource(nameof(NullableRows))] + public void Value((T, T?) row) where T : struct + { + if (typeof(T) != typeof(long) || !Equals(row.Item1, 1L) + || row.Item2 is not null && !Equals(row.Item2, 2L)) + throw new InvalidOperationException("Expected long inference through nullable element and converted first element"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + [MethodDataSource(nameof(NullableReferenceRows))] + public void Reference(Tuple row) where T : struct + { + if (typeof(T) != typeof(long) || !Equals(row.Item1, 3L) + || row.Item2 is not null && !Equals(row.Item2, 4L)) + throw new InvalidOperationException("Expected long inference through nullable reference-tuple element"); + } +} + +public class RepeatedNestedGenericTupleTests +{ + public static IEnumerable<(int, List)> ValueRows() => [(1, new List { 2 })]; + public static IEnumerable>> ReferenceRows() => [Tuple.Create(3, new List { 4 })]; + public static IEnumerable<(int, long[])> ArrayRows() => [(5, new long[] { 6 })]; + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void Value((T, List) row) + { + if (typeof(T) != typeof(long) || !Equals(row.Item1, 1L) || !Equals(row.Item2[0], 2L)) + throw new InvalidOperationException("Expected long inference through a nested generic element"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void Reference(Tuple> row) + { + if (typeof(T) != typeof(long) || !Equals(row.Item1, 3L) || !Equals(row.Item2[0], 4L)) + throw new InvalidOperationException("Expected long inference through a reference tuple generic element"); + } + + [Test] + [MethodDataSource(nameof(ArrayRows))] + public void Array((T, T[]) row) + { + if (typeof(T) != typeof(long) || !Equals(row.Item1, 5L) || !Equals(row.Item2[0], 6L)) + throw new InvalidOperationException("Expected long inference through an array element"); + } +} + +// Ordinary parameters retain their existing inference policy; generic-base traversal is tuple-only. +public class OrdinaryGenericBaseInferenceTests +{ + public class Base { } + public sealed class Derived : Base { } + public static IEnumerable Rows() => [new Derived()]; + + [Test] + // Intentionally exercises uninferable ordinary generic-base parameters. +#pragma warning disable TUnit0001 + [MethodDataSource(nameof(Rows))] +#pragma warning restore TUnit0001 + public void Ordinary(Base value) { } +} + +public class TupleNestedInterfaceBaseTests +{ + public class Base { } + public sealed class Derived : Base { } + public static IEnumerable<(List, int)> Rows() => [(new() { new Derived() }, 7)]; + public static IEnumerable, int>> ReferenceRows() => [Tuple.Create(new List { new() }, 7)]; + + [Test] + [MethodDataSource(nameof(Rows))] + public void Value((IEnumerable>, int) row) + { + if (typeof(T) != typeof(int) || row.Item1.Single() is not Derived || row.Item2 != 7) + throw new InvalidOperationException("Expected base inference through an interface candidate"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void Reference(Tuple>, int> row) + { + if (typeof(T) != typeof(int) || row.Item1.Single() is not Derived || row.Item2 != 7) + throw new InvalidOperationException("Expected reference tuple base inference through an interface candidate"); + } +} + +public class TupleMultiParameterCandidateTests +{ + public interface IPair { } + public sealed class Dual : IPair, IPair { } + public static IEnumerable<(string, Dual)> Rows() => [("value", new())]; + public static IEnumerable> ReferenceRows() => [Tuple.Create("value", new Dual())]; + + [Test] + [MethodDataSource(nameof(Rows))] + public void Value((T, IPair) row) + { + if (typeof(T) != typeof(string) || typeof(U) != typeof(long) || row.Item2 is not Dual) + throw new InvalidOperationException("Expected rejected candidates to leave no partial type bindings"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void Reference(Tuple> row) + { + if (typeof(T) != typeof(string) || typeof(U) != typeof(long) || row.Item2 is not Dual) + throw new InvalidOperationException("Expected reference tuple candidate isolation during invocation"); + } +} + +// Cross-family reconstruction applies to whole tuple rows, not ordinary spread columns. +public class SpreadCrossFamilyTupleInferenceTests +{ + public static IEnumerable<(Tuple, int)> Rows() => [(Tuple.Create(1, "value"), 7)]; + + [Test] +#pragma warning disable TUnit0001 // Intentionally uninferable spread column. + [MethodDataSource(nameof(Rows))] +#pragma warning restore TUnit0001 + public void Value((T, string) row, int extra) { } +} + +public class TupleClosedCandidateArgumentTests +{ + public interface IPair { } + public sealed class Dual : IPair, IPair { } + public static IEnumerable<(string, Dual)> Rows() => [("value", new())]; + public static IEnumerable> ReferenceRows() => [Tuple.Create("value", new Dual())]; + + [Test] + [MethodDataSource(nameof(Rows))] + public void Value((T, IPair) row) + { + if (typeof(T) != typeof(string) || typeof(U) != typeof(long) || row.Item2 is not Dual) + throw new InvalidOperationException("Expected incompatible closed candidate arguments to be rejected"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void Reference(Tuple> row) + { + if (typeof(T) != typeof(string) || typeof(U) != typeof(long) || row.Item2 is not Dual) + throw new InvalidOperationException("Expected reference tuple closed candidate validation"); + } +} + +public class SpreadMatchingFamilyTupleInferenceTests +{ + public class Base { } + public sealed class Derived : Base { } + public static IEnumerable<((Derived, int), int)> Rows() => [((new(), 1), 7)]; + + [Test] +#pragma warning disable TUnit0001 // Intentionally uninferable spread column. + [MethodDataSource(nameof(Rows))] +#pragma warning restore TUnit0001 + public void Value((Base, int) row, int extra) { } +} + + +public class TupleVariantCandidateTests +{ + public interface IPair { } + public interface IConsumer { } + public sealed class Source : IPair, IConsumer { } + public static IEnumerable<(Source, int)> ValueRows() => [(new Source(), 7)]; + public static IEnumerable> ReferenceRows() => [Tuple.Create(new Source(), 7)]; + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void Value((IPair, int) row) + { + if (typeof(T) != typeof(int) || row.Item1 is not Source || row.Item2 != 7) + throw new InvalidOperationException("Expected covariant interface conversion"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void Reference(Tuple, int> row) + { + if (typeof(T) != typeof(int) || row.Item1 is not Source || row.Item2 != 7) + throw new InvalidOperationException("Expected covariant interface conversion"); + } + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void ContravariantValue((IConsumer, int) row) + { + if (typeof(T) != typeof(int) || row.Item1 is not Source || row.Item2 != 7) + throw new InvalidOperationException("Expected contravariant interface conversion"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void ContravariantReference(Tuple, int> row) + { + if (typeof(T) != typeof(int) || row.Item1 is not Source || row.Item2 != 7) + throw new InvalidOperationException("Expected contravariant interface conversion"); + } +} + + +public class TupleInvariantBaseCandidateTests +{ + public interface IBox { } + public class Base { } + public sealed class Derived : Base { } + public sealed class Dual : IBox, IBox> { } + public static IEnumerable<(Dual, int)> ValueRows() => [(new Dual(), 7)]; + public static IEnumerable> ReferenceRows() => [Tuple.Create(new Dual(), 7)]; + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void Value((IBox>, int) row) + { + if (typeof(T) != typeof(long) || row.Item1 is not Dual || row.Item2 != 7) + throw new InvalidOperationException("Expected compatible invariant base candidate"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void Reference(Tuple>, int> row) + { + if (typeof(T) != typeof(long) || row.Item1 is not Dual || row.Item2 != 7) + throw new InvalidOperationException("Expected compatible invariant base candidate"); + } +} + + +public class TupleConstrainedCandidateTests +{ + public interface IFoo { } + public sealed class Foo : IFoo { } + public interface IPair where A : B { } + public sealed class Dual : IPair, IPair { } + public static IEnumerable<(Dual, int)> ValueRows() => [(new Dual(), 7)]; + public static IEnumerable> ReferenceRows() => [Tuple.Create(new Dual(), 7)]; + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void Value((IPair, int) row) where T : IFoo + { + if (typeof(T) != typeof(Foo) || row.Item1 is not Dual || row.Item2 != 7) + throw new InvalidOperationException("Expected constraint-invalid candidate to be skipped"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void Reference(Tuple, int> row) where T : IFoo + { + if (typeof(T) != typeof(Foo) || row.Item1 is not Dual || row.Item2 != 7) + throw new InvalidOperationException("Expected reference tuple constraint-invalid candidate to be skipped"); + } +} + +// Singleton tuple reconstruction has the analyzer false positive tracked by #7622. +#pragma warning disable TUnit0001 +public class SingletonTupleInferenceTests +{ + public static IEnumerable> ReferenceRows() => [Tuple.Create(7)]; + public static IEnumerable> ValueRows() => [new(7)]; + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void ReferenceToValue(ValueTuple row) + { + if (typeof(T) != typeof(int) || !Equals(row.Item1, 7)) + throw new InvalidOperationException("Expected singleton reference-to-value tuple reconstruction"); + } + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void ValueToReference(Tuple row) + { + if (typeof(T) != typeof(int) || !Equals(row.Item1, 7)) + throw new InvalidOperationException("Expected singleton value-to-reference tuple reconstruction"); + } + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void ValueToValue(ValueTuple row) + { + if (typeof(T) != typeof(int) || !Equals(row.Item1, 7)) + throw new InvalidOperationException("Expected singleton value tuple inference"); + } +} + +#pragma warning restore TUnit0001 + + +public class OpenTupleRuntimeCastTests +{ + public static IEnumerable<(int, object)> ValueRows() => [(1, new List { 7 })]; + public static IEnumerable> ReferenceRows() => [Tuple.Create(1, (object)new List { 7 })]; + public static IEnumerable<(object, int)> ReversedRows() => [(new List { 7 }, 1)]; + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void Value((T, List) row) + { + if (typeof(T) != typeof(int) || !Equals(row.Item1, 1) || !Equals(row.Item2.Single(), 7)) + throw new InvalidOperationException("Expected open element runtime cast after inference"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void Reference(Tuple> row) + { + if (typeof(T) != typeof(int) || !Equals(row.Item1, 1) || !Equals(row.Item2.Single(), 7)) + throw new InvalidOperationException("Expected reference tuple open element runtime cast"); + } + + [Test] + [MethodDataSource(nameof(ReversedRows))] + public void Reversed((List, T) row) + { + if (typeof(T) != typeof(int) || !Equals(row.Item1.Single(), 7) || !Equals(row.Item2, 1)) + throw new InvalidOperationException("Expected inference from a later element after a runtime cast"); + } + + public static IEnumerable<(int, IEnumerable)> InterfaceRows() => [(1, new List { 7 })]; + public static IEnumerable>> ReferenceInterfaceRows() => + [Tuple.Create(1, (IEnumerable)new List { 7 })]; + public static IEnumerable<(IEnumerable, int)> ReversedInterfaceRows() => [(new List { 7 }, 1)]; + public class Base { } + public sealed class Derived : Base { } + public static IEnumerable<(int, Base)> BaseRows() => [(1, new Derived())]; + + [Test] + [MethodDataSource(nameof(InterfaceRows))] + public void Interface((T, List) row) => Value(row); + + [Test] + [MethodDataSource(nameof(ReferenceInterfaceRows))] + public void ReferenceInterface(Tuple> row) => Reference(row); + + [Test] + [MethodDataSource(nameof(ReversedInterfaceRows))] + public void ReversedInterface((List, T) row) => Reversed(row); + + [Test] + [MethodDataSource(nameof(BaseRows))] + public void BaseCast((T, Derived) row) + { + if (typeof(T) != typeof(int) || !Equals(row.Item1, 1) || row.Item2 is null) + throw new InvalidOperationException("Expected base-typed element runtime cast after inference"); + } + +} + + +#pragma warning disable TUnit0001 // #7622: analyzer tuple reconstruction and whole-row matching. +public class NestedSingletonBoundaryTests +{ + public static IEnumerable>> Rows() => [Tuple.Create(new ValueTuple(7))]; + + [Test] + [MethodDataSource(nameof(Rows))] + public void ReferenceOuter(Tuple> row) + { + if (row.Item1.Item1 != 7) + throw new InvalidOperationException("Expected nested singleton reconstruction"); + } + + [Test] + [MethodDataSource(nameof(Rows))] + public void ValueOuter(ValueTuple> row) + { + if (row.Item1.Item1 != 7) + throw new InvalidOperationException("Expected preserved whole singleton reconstruction"); + } +} + +public class WrappedNestedSingletonInferenceTests +{ + public static IEnumerable>>> Rows() => + [new(Tuple.Create(new ValueTuple(7)))]; + public static IEnumerable>>> ValueRows() => + [new(new ValueTuple>(Tuple.Create(7)))]; + + [Test] + [MethodDataSource(nameof(Rows))] + public void ReferenceOuter(Tuple> row) + { + if (typeof(T) != typeof(int) || !Equals(row.Item1.Item1, 7)) + throw new InvalidOperationException("Expected wrapped nested singleton inference"); + } + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void ValueOuter(ValueTuple> row) + { + if (typeof(T) != typeof(int) || !Equals(row.Item1.Item1, 7)) + throw new InvalidOperationException("Expected wrapped value nested singleton inference"); + } +} + +public class WrappedWholeTupleInferenceTests +{ + public static IEnumerable> ValueRows() => [new((1, "tuple"))]; + public static IEnumerable>> ReferenceRows() => [new(Tuple.Create(1, "tuple"))]; + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void ValueOptional((T, string) row, int extra = 5) + { + if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra != 5) + throw new InvalidOperationException("Expected whole value tuple and default optional value"); + } + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void ValueParams((T, string) row, params int[] extra) + { + if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra.Length != 0) + throw new InvalidOperationException("Expected whole value tuple and empty params"); + } + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void ValueArray((T, string) row, int[] extra) + { + if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra.Length != 0) + throw new InvalidOperationException("Expected whole value tuple and empty collecting array"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void ReferenceOptional(Tuple row, int extra = 5) + { + if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra != 5) + throw new InvalidOperationException("Expected whole reference tuple and default optional value"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void ReferenceParams(Tuple row, params int[] extra) + { + if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra.Length != 0) + throw new InvalidOperationException("Expected whole reference tuple and empty params"); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void ReferenceArray(Tuple row, int[] extra) + { + if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra.Length != 0) + throw new InvalidOperationException("Expected whole reference tuple and empty collecting array"); + } +} +#pragma warning restore TUnit0001 + + +// #7622: analyzer does not model deferred tuple-element runtime casts. +#pragma warning disable TUnit0001 +public class OpenTupleArrayRuntimeCastTests +{ + public static IEnumerable<(int, object)> ValueRows() => [(1, new[] { 7 })]; + public static IEnumerable> ReferenceRows() => [Tuple.Create(1, (object)new[] { 7 })]; + public static IEnumerable<(int, IEnumerable)> InterfaceRows() => [(1, new[] { 7 })]; + public static IEnumerable<(object, int)> ReversedRows() => [(new[] { 7 }, 1)]; + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void Value((T, T[]) row) => Verify(row.Item1, row.Item2); + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void Reference(Tuple row) => Verify(row.Item1, row.Item2); + + [Test] + [MethodDataSource(nameof(InterfaceRows))] + public void Interface((T, T[]) row) => Verify(row.Item1, row.Item2); + + [Test] + [MethodDataSource(nameof(ReversedRows))] + public void Reversed((T[], T) row) => Verify(row.Item2, row.Item1); + + private static void Verify(T first, T[] array) + { + if (typeof(T) != typeof(int) || !Equals(first, 1) || array.Length != 1 || !Equals(array[0], 7)) + throw new InvalidOperationException("Expected array runtime cast after tuple inference"); + } +} + +#pragma warning restore TUnit0001 + +public class NestedTupleCandidateBindingTests +{ + public interface IBox { } + public sealed class Dual : IBox<(int, int)>, IBox<(long, string)> { } + public sealed class NestedDual : IBox>, IBox> { } + + public static IEnumerable<(string, Dual)> ValueRows() => [("value", new Dual())]; + public static IEnumerable> ReferenceRows() => [Tuple.Create("value", new Dual())]; + public static IEnumerable<(string, NestedDual)> NestedValueRows() => [("value", new NestedDual())]; + public static IEnumerable> NestedReferenceRows() => [Tuple.Create("value", new NestedDual())]; + + [Test] + [MethodDataSource(nameof(ValueRows))] + public void Value((T, IBox<(U, T)>) row) + { + Verify(row.Item1); + } + + [Test] + [MethodDataSource(nameof(ReferenceRows))] + public void Reference(Tuple> row) + { + Verify(row.Item1); + } + + [Test] + [MethodDataSource(nameof(NestedValueRows))] + public void NestedValue((T, IBox>) row) + { + Verify(row.Item1); + } + + [Test] + [MethodDataSource(nameof(NestedReferenceRows))] + public void NestedReference(Tuple>> row) + { + Verify(row.Item1); + } + + private static void Verify(T value) + { + if (typeof(T) != typeof(string) || typeof(U) != typeof(long) || !Equals(value, "value")) + throw new InvalidOperationException("Expected nested candidate to preserve the string binding and infer long"); + } +} + +// #7622: analyzer spreads whole tuple rows with optional or collecting tails. +#pragma warning disable TUnit0001 +public class ExplicitWholeTupleInferenceTests +{ + public static IEnumerable> Rows() => [() => (1, "tuple")]; + public static IEnumerable> NestedRows() => [() => ((1, "tuple"), 7)]; + + [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(Rows))] + public void Optional((T, string) row, int extra = 5) + { + if (row.Item1 is not (int or long) || row.Item2 != "tuple" || extra != 5) + throw new InvalidOperationException("Expected whole tuple and optional default"); + } + + [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(Rows))] + public void Params((T, string) row, params int[] extra) + { + if (row.Item1 is not (int or long) || row.Item2 != "tuple" || extra.Length != 0) + throw new InvalidOperationException("Expected whole tuple and empty params"); + } + + [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(Rows))] + public void Array((T, string) row, int[] extra) + { + if (row.Item1 is not (int or long) || row.Item2 != "tuple" || extra.Length != 0) + throw new InvalidOperationException("Expected whole tuple and empty trailing array"); + } + + [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(NestedRows))] + public void Nested((T, string) row, int extra = 5) + { + if (row.Item1 is not (int or long) || row.Item2 != "tuple" || extra != 7) + throw new InvalidOperationException("Expected nested tuple with supplied column"); + } +} + +#pragma warning restore TUnit0001 + +// #7622: analyzer spreads whole tuple rows before explicit method-type inference. +#pragma warning disable TUnit0001 +public class ExplicitCrossFamilyTupleInferenceTests +{ + public static IEnumerable>> ReferenceRows() => [() => Tuple.Create(1, "tuple")]; + public static IEnumerable> ValueRows() => [() => (1, "tuple")]; + + [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(ReferenceRows))] + public void ReferenceToValue((T, string) row) + { + Verify(row.Item1, row.Item2); + } + + [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(ReferenceRows))] + public void ReferenceToReference(Tuple row) + { + Verify(row.Item1, row.Item2); + } + + [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(ValueRows))] + public void ValueToReference(Tuple row) + { + Verify(row.Item1, row.Item2); + } + + private static void Verify(T value, string text) + { + if (typeof(T) != typeof(int) && typeof(T) != typeof(long) + || value is not (int or long) || Convert.ToInt64(value) != 1 || text != "tuple") + throw new InvalidOperationException("Expected both explicit long and inferred int tuple instantiations"); + } +} + +#pragma warning restore TUnit0001 + +// #7622: analyzer spreads whole reference-tuple rows for a bare type parameter. +#pragma warning disable TUnit0001 +public class ExplicitBareReferenceTupleInferenceTests +{ + public static IEnumerable>> Rows() => [() => Tuple.Create(1, "tuple")]; + + [Test, GenerateGenericTest(typeof(Tuple)), MethodDataSource(nameof(Rows))] + public void WholeRow(T row) + { + if (typeof(T) != typeof(Tuple) || row is not Tuple { Item1: 1, Item2: "tuple" }) + throw new InvalidOperationException("Expected only the whole reference-tuple instantiation"); + } +} +#pragma warning restore TUnit0001 + +// #7622: analyzer spreads whole tuple rows before explicit method-type inference. +#pragma warning disable TUnit0001 +public class ExplicitDirectTupleInferenceTests +{ + public static IEnumerable<(int, string)> ValueRows() => [(1, "tuple")]; + public static IEnumerable> ReferenceRows() => [Tuple.Create(1, "tuple")]; + + [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(ValueRows))] + public void Value((T, string) row) => Verify(row.Item1, row.Item2); + + [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(ReferenceRows))] + public void Reference(Tuple row) => Verify(row.Item1, row.Item2); + + [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(ReferenceRows))] + public void ReferenceToValue((T, string) row) => Verify(row.Item1, row.Item2); + + private static void Verify(T value, string text) + { + if (typeof(T) != typeof(int) && typeof(T) != typeof(long) + || value is not (int or long) || Convert.ToInt64(value) != 1 || text != "tuple") + throw new InvalidOperationException("Expected both explicit long and inferred int direct tuple instantiations"); + } +} +#pragma warning restore TUnit0001 + +// #7622: analyzer spreads whole tuple rows with optional tails. +#pragma warning disable TUnit0001 +public class ExplicitWrappedTupleInferenceTests +{ + public static IEnumerable> Rows() => [new((1, "tuple"))]; + public static IEnumerable>> InnerRows() => [new(() => (1, "tuple"))]; + public static IEnumerable>>> OuterRows() => [() => new(() => (1, "tuple"))]; + + [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(Rows))] + public void Direct((T, string) row, int extra = 5) => Verify(row, extra); + + [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(InnerRows))] + public void Inner((T, string) row, int extra = 5) => Verify(row, extra); + + [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(OuterRows))] + public void Outer((T, string) row, int extra = 5) => Verify(row, extra); + + private static void Verify((T, string) row, int extra) + { + if (typeof(T) != typeof(int) || Convert.ToInt64(row.Item1) != 1 || row.Item2 != "tuple" || extra != 5) + throw new InvalidOperationException("Expected inferred int whole row and optional default"); + } +} +#pragma warning restore TUnit0001 + +// #7622: analyzer does not apply nullable structural inference to spread columns. +#pragma warning disable TUnit0001 +public class ExplicitSpreadColumnInferenceTests +{ + public static IEnumerable<(int, long[])> ArrayRows() => [(1, [2L])]; + public static IEnumerable<(int, long)> NullableRows() => [(1, 2L)]; + + [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(ArrayRows))] + public void Array(T first, T[] extra) + { + if (typeof(T) != typeof(long) || Convert.ToInt64(first) != 1 || extra.Length != 1 || Convert.ToInt64(extra[0]) != 2) + throw new InvalidOperationException("Expected only long inferred from the array column"); + } + + [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(NullableRows))] + public void Nullable(T first, T? extra) where T : struct + { + if (typeof(T) != typeof(long) || Convert.ToInt64(first) != 1 || Convert.ToInt64(extra) != 2) + throw new InvalidOperationException("Expected only long inferred from the nullable column"); + } +} + +#pragma warning restore TUnit0001 diff --git a/tests/TUnit.UnitTests/DataSourceHelpersTests.cs b/tests/TUnit.UnitTests/DataSourceHelpersTests.cs index db8ddb9025c..de5b009ec79 100644 --- a/tests/TUnit.UnitTests/DataSourceHelpersTests.cs +++ b/tests/TUnit.UnitTests/DataSourceHelpersTests.cs @@ -8,6 +8,70 @@ namespace TUnit.UnitTests; /// public class DataSourceHelpersTests { + private static void OpenTuple(Tuple row) { } + + private static void ObjectTuple(Tuple row) { } + + [Test] + public async Task NullRow_DoesNotMatchOpenTupleWithTrailingParameter() + { + var parameter = typeof(DataSourceHelpersTests).GetMethod(nameof(OpenTuple), + System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic)!.GetParameters()[0].ParameterType; + object?[] values = [null]; + var result = TUnit.Engine.Helpers.DataUnwrapper.UnwrapWithTypes(values, + [new ParameterMetadata(parameter) { Name = "row", TypeInfo = new ConcreteType(parameter) }, + new ParameterMetadata(typeof(int)) { Name = "extra", TypeInfo = new ConcreteType(typeof(int)), CachedIsOptional = true }]); + + await Assert.That(result.Length).IsEqualTo(1); + await Assert.That(result[0]).IsNull(); + } + + + [Test] + public async Task OpenTupleBinding_RequiresOuterAssignability() + { + var parameter = typeof(DataSourceHelpersTests).GetMethod(nameof(ObjectTuple), + System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic)!.GetParameters()[0].ParameterType; + var whole = Tuple.Create(1, new object()); + var nested = Tuple.Create(whole, "extra"); + await Assert.That(TupleHelper.MatchesOpenTuple(parameter, whole.GetType())).IsTrue(); + await Assert.That(TupleHelper.MatchesOpenTuple(parameter, nested.GetType())).IsFalse(); + await Assert.That(nested.ToObjectArrayWithTypes([parameter, typeof(string)]).Length).IsEqualTo(2); + } + + private static void RepeatedTuple(Tuple row) { } + + [Test] + public async Task OpenTupleBinding_RequiresConsistentRepeatedParameters() + { + var parameter = typeof(DataSourceHelpersTests).GetMethod(nameof(RepeatedTuple), + System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic)!.GetParameters()[0].ParameterType; + var whole = Tuple.Create(1, 2); + var nested = Tuple.Create(whole, Tuple.Create(7, "extra")); + await Assert.That(TupleHelper.MatchesOpenTuple(parameter, whole.GetType())).IsTrue(); + await Assert.That(TupleHelper.MatchesOpenTuple(parameter, nested.GetType())).IsFalse(); + await Assert.That(nested.ToObjectArrayWithTypes([parameter, typeof(Tuple)]).Length).IsEqualTo(2); + } + + [Test] + public async Task OpenTupleBinding_DistinguishesWholeAndNestedRows() + { + var parameter = typeof(DataSourceHelpersTests).GetMethod(nameof(OpenTuple), + System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic)!.GetParameters()[0].ParameterType; + var whole = Tuple.Create(1, "tuple"); + var nested = Tuple.Create(whole, 7); + var mismatched = Tuple.Create(1, 2); + + await Assert.That(TupleHelper.MatchesOpenTuple(parameter, whole.GetType())).IsTrue(); + await Assert.That(TupleHelper.MatchesOpenTuple(parameter, nested.GetType())).IsFalse(); + await Assert.That(TupleHelper.MatchesOpenTuple(parameter, mismatched.GetType())).IsFalse(); + await Assert.That(whole.ToObjectArrayWithTypes([parameter, typeof(int)]).Length).IsEqualTo(1); + var columns = nested.ToObjectArrayWithTypes([parameter, typeof(int)]); + await Assert.That(columns.Length).IsEqualTo(2); + await Assert.That(columns[0]).IsEqualTo((object)whole); + await Assert.That(columns[1]).IsEqualTo((object)7); + } + [Test] [Arguments(null, false)] [Arguments("text", true)]