# NUnit Parameterised Tests
## UseParameters()
`UseParameters()` controls what parameters are used when naming files.
Verify.NUnit automatically detects the method parameters. So `UseParameters()` is not required unless using custom parameters.
If not all parameters are required, a subset can be passed in. In this scenario, the parameters passed in will match with the method parameter names from the start. For example the following will result in a file named `ParametersSample.UseParametersSubSet_arg1=Value1_arg2=Value2.verified.txt`
```cs
[TestCase("Value1", "Value2", "Value3")]
public Task UseParametersSubSet(string arg1, string arg2, string arg3)
{
var somethingToVerify = $"{arg1} {arg2} {arg3} some text";
return Verify(somethingToVerify)
.UseParameters(arg1, arg2);
}
```
snippet source | anchor
If the number of parameters passed to `UseParameters()` is greater than the number of parameters in the test method, an exception will be thrown.
### TestCase
```cs
[TestCase("Value1")]
[TestCase("Value2")]
public Task TestCaseUsage(string arg) =>
Verify(arg);
```
snippet source | anchor
### TestFixtureSourceUsage
When using a [TestFixtureSource](https://docs.nunit.org/articles/nunit/writing-tests/attributes/testfixturesource.html) the name provided by NUnit will be as the `TestMethodName`.
```cs
[TestFixtureSource(nameof(FixtureArgs))]
public class TestFixtureSourceUsage(string arg1, int arg2)
{
[Test]
public Task Test() =>
Verify(
new
{
arg1,
arg2
});
static object[] FixtureArgs =
[
new object[]
{
"Value1",
1
},
new object[]
{
"Value2",
2
}
];
}
```
snippet source | anchor
Produces:
* `TestFixtureSourceUsage.Test_arg1=Value1_arg2=1.verified.txt`
* `TestFixtureSourceUsage.Test_arg1=Value2_arg2=2.verified.txt`
### Unknown parameter types
For unknown types the parameter information cannot be derived. In these scenarios `ToString()` is used. To use custom text for a parameter use `NameForParameter()`.
```cs
public class ComplexParametersSample
{
[ModuleInitializer]
public static void Initialize() =>
VerifierSettings.NameForParameter(_ => _.Value);
[TestCaseSource(nameof(GetData))]
public Task ComplexTestCaseSource(ComplexData arg) =>
Verify(arg);
public static IEnumerable GetData()
{
yield return
[
new ComplexData("Value1")
];
yield return
[
new ComplexData("Value2")
];
}
public record ComplexData(string Value);
}
```
snippet source | anchor
## Overriding text used for parameters
`UseTextForParameters()` can be used to override the substitution text used for the `{Parameters}` part of the file convention.
```
{Directory}/{TestClassName}.{TestMethodName}_{Parameters}_{UniqueFor1}_{UniqueFor2}_{UniqueForX}.verified.{extension}
```
The below samples produce:
For the instance case:
* TheTest.UseTextForParameters_Value1.verified.txt
* TheTest.UseTextForParameters_Value2.verified.txt
For the fluent case:
* TheTest.UseTextForParametersFluent_Value1.verified.txt
* TheTest.UseTextForParametersFluent_Value2.verified.txt
### Instance
```cs
[TestCase("Value1")]
[TestCase("Value2")]
public Task UseTextForParameters(string arg)
{
var settings = new VerifySettings();
settings.UseTextForParameters(arg);
return Verify(arg + "UseTextForParameters", settings);
}
```
snippet source | anchor
### Fluent
```cs
[TestCase("Value1")]
[TestCase("Value2")]
public Task UseTextForParametersFluent(string arg) =>
Verify(arg + "UseTextForParametersFluent")
.UseTextForParameters(arg);
```
snippet source | anchor
## Ignore parameters for verified filename
By default, Verify expects every parameterized case to have a unique [file name](/docs/naming.md) with the parameters appended to the file name. This behavior can be overridden by using `IgnoreParametersForVerified()`. In this case, the verified file name does not contain the parameter values, meaning it is the same for each testcase.
`IgnoreParametersForVerified` accepts an array for passing through the parameters. These values are passed to [UseParameters](#UseParameters). This is required for MSTest, and xUnit. Parameters should not be passed for NUnit, TUnit and Fixie since they are automatically detected.
The below samples produce:
For the instance case:
* NamerTests.IgnoreParametersForVerified_arg=One.received.txt
* NamerTests.IgnoreParametersForVerified_arg=Two.received.txt
* NamerTests.IgnoreParametersForVerified.verified.txt
For the fluent case:
* NamerTests.IgnoreParametersForVerifiedFluent_arg=One.received.txt
* NamerTests.IgnoreParametersForVerifiedFluent_arg=Two.received.txt
* NamerTests.IgnoreParametersForVerifiedFluent.verified.txt
### Instance
```cs
[TestCase("One")]
[TestCase("Two")]
public Task IgnoreParametersForVerified(string arg)
{
var settings = new VerifySettings();
settings.IgnoreParametersForVerified();
return Verify("value", settings);
}
```
snippet source | anchor
### Fluent
```cs
[TestCase("One")]
[TestCase("Two")]
public Task IgnoreParametersForVerifiedFluent(string arg) =>
Verify("value")
.IgnoreParametersForVerified();
```
snippet source | anchor
## IgnoreParametersForVerified with override parameters
The parameters passed to IgnoreParametersForVerified can be used pass custom parameters to [UseParameters](#UseParameters).
### Instance
```cs
[TestCase("One")]
[TestCase("Two")]
public Task IgnoreParametersForVerifiedCustomParams(string arg)
{
var settings = new VerifySettings();
settings.IgnoreParametersForVerified($"Number{arg}");
return Verify("value", settings);
}
```
snippet source | anchor
### Fluent
```cs
[TestCase("One")]
[TestCase("Two")]
public Task IgnoreParametersForVerifiedCustomParamsFluent(string arg) =>
Verify("value")
.IgnoreParametersForVerified($"Number{arg}");
```
snippet source | anchor