TestCaseAttribute
public class TestCaseAttribute : NUnitAttribute, ITestBuilder, ITestCaseData, ITestData, IImplyFixture
Marks a method as a parameterized test suite and provides arguments for each test case.
using NUnit.Framework.Interfaces;
using NUnit.Framework.Internal;
using NUnit.Framework.Internal.Extensions;
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
namespace NUnit.Framework
{
[NullableContext(2)]
[Nullable(0)]
[AttributeUsage(AttributeTargets.Method, AllowMultiple = true, Inherited = false)]
public class TestCaseAttribute : NUnitAttribute, ITestBuilder, ITestCaseData, ITestData, IImplyFixture
{
private object _expectedResult;
private RunState _originalRunState;
private DateTimeOffset? _untilDate;
private Type _testOf;
public string TestName { get; set; }
public RunState RunState { get; set; }
[Nullable(new byte[] {
1,
2
})]
[field: Nullable(new byte[] {
1,
2
})]
public object[] Arguments {
[return: Nullable(new byte[] {
1,
2
})]
get;
}
[Nullable(1)]
[field: Nullable(1)]
public IPropertyBag Properties {
[NullableContext(1)]
get;
}
public object ExpectedResult {
get {
return _expectedResult;
}
set {
_expectedResult = value;
HasExpectedResult = true;
}
}
public bool HasExpectedResult { get; set; }
public string Description {
get {
return Properties.Get("Description") as string;
}
[param: DisallowNull]
set {
Guard.ArgumentNotNull(value, "value");
Properties.Set("Description", value);
}
}
public string Author {
get {
return Properties.Get("Author") as string;
}
[param: DisallowNull]
set {
Guard.ArgumentNotNull(value, "value");
Properties.Set("Author", value);
}
}
public Type TestOf {
get {
return _testOf;
}
[param: DisallowNull]
set {
Guard.ArgumentNotNull(value, "value");
_testOf = value;
Properties.Set("TestOf", value.FullName());
}
}
public string Ignore {
get {
return IgnoreReason;
}
[param: DisallowNull]
set {
Guard.ArgumentNotNull(value, "value");
IgnoreReason = value;
}
}
public bool Explicit {
get {
return RunState == RunState.Explicit;
}
set {
RunState = ((!value) ? RunState.Runnable : RunState.Explicit);
}
}
public string Reason {
get {
return Properties.Get("_SKIPREASON") as string;
}
[param: DisallowNull]
set {
Guard.ArgumentNotNull(value, "value");
Properties.Set("_SKIPREASON", value);
}
}
public string IgnoreReason {
get {
return Reason;
}
[param: DisallowNull]
set {
Guard.ArgumentNotNull(value, "value");
_originalRunState = RunState;
RunState = RunState.Ignored;
Reason = value;
}
}
public string IncludePlatform { get; set; }
public string ExcludePlatform { get; set; }
[Nullable(new byte[] {
2,
1
})]
[field: Nullable(new byte[] {
2,
1
})]
public Type[] TypeArgs {
[return: Nullable(new byte[] {
2,
1
})]
get;
[param: Nullable(new byte[] {
2,
1
})]
set;
}
public string Category {
get {
return Properties.Get("Category") as string;
}
[param: DisallowNull]
set {
Guard.ArgumentNotNull(value, "value");
foreach (string item in value.Tokenize(',', false)) {
Properties.Add("Category", item);
}
}
}
[StringSyntax("DateTimeFormat")]
public string Until {
get {
return Properties.Get("IgnoreUntilDate") as string;
}
[param: DisallowNull]
set {
if (!string.IsNullOrEmpty(IgnoreReason)) {
_untilDate = DateTimeOffset.Parse(value, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
Properties.Set("IgnoreUntilDate", _untilDate.Value.ToString("u"));
} else
RunState = RunState.NotRunnable;
}
}
public TestCaseAttribute(params object[] arguments)
{
RunState = RunState.Runnable;
if (arguments == null)
Arguments = new object[1];
else
Arguments = arguments;
Properties = new PropertyBag();
}
public TestCaseAttribute(object arg)
{
RunState = RunState.Runnable;
Arguments = new object[1] {
arg
};
Properties = new PropertyBag();
}
public TestCaseAttribute(object arg1, object arg2)
{
RunState = RunState.Runnable;
Arguments = new object[2] {
arg1,
arg2
};
Properties = new PropertyBag();
}
public TestCaseAttribute(object arg1, object arg2, object arg3)
{
RunState = RunState.Runnable;
Arguments = new object[3] {
arg1,
arg2,
arg3
};
Properties = new PropertyBag();
}
[NullableContext(1)]
private TestCaseParameters GetParametersForTestCase(IMethodInfo method)
{
try {
IParameterInfo[] parameters = method.GetParameters();
int num = parameters.Length;
int num2 = Arguments.Length;
TestCaseParameters testCaseParameters = new TestCaseParameters(this) {
TypeArgs = TypeArgs
};
if (testCaseParameters.HasExpectedResult && ParamAttributeTypeConversions.TryConvert(testCaseParameters.ExpectedResult, method.ReturnType.Type, out object convertedValue))
testCaseParameters.ExpectedResult = convertedValue;
if (parameters.LastParameterAcceptsCancellationToken() && !Arguments.LastArgumentIsCancellationToken())
num2++;
if (num > 0 && num2 >= num - 1) {
IParameterInfo parameterInfo = parameters[num - 1];
Type parameterType = parameterInfo.ParameterType;
Type elementType = parameterType.GetElementType();
if (parameterType.IsArray && parameterInfo.IsDefined<ParamArrayAttribute>(false)) {
if (num2 == num) {
if (!parameterType.IsInstanceOfType(testCaseParameters.Arguments[num2 - 1])) {
Array array = Array.CreateInstance(elementType, 1);
array.SetValue(testCaseParameters.Arguments[num2 - 1], 0);
testCaseParameters.Arguments[num2 - 1] = array;
}
} else {
object[] array2 = new object[num];
for (int i = 0; i < num && i < num2; i++) {
array2[i] = testCaseParameters.Arguments[i];
}
int num3 = num2 - num + 1;
Array array3 = Array.CreateInstance(elementType, num3);
for (int j = 0; j < num3; j++) {
array3.SetValue(testCaseParameters.Arguments[num + j - 1], j);
}
array2[num - 1] = array3;
testCaseParameters.Arguments = array2;
num2 = num;
}
}
}
if (num2 < num) {
object[] array4 = new object[parameters.Length];
Array.Copy(testCaseParameters.Arguments, array4, testCaseParameters.Arguments.Length);
for (int k = testCaseParameters.Arguments.Length; k < parameters.Length; k++) {
if (parameters[k].IsOptional)
array4[k] = Type.Missing;
else {
if (k >= testCaseParameters.Arguments.Length) {
DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(63, 2);
defaultInterpolatedStringHandler.AppendLiteral("Method requires ");
defaultInterpolatedStringHandler.AppendFormatted(num);
defaultInterpolatedStringHandler.AppendLiteral(" arguments but TestCaseAttribute only supplied ");
defaultInterpolatedStringHandler.AppendFormatted(num2);
throw new TargetParameterCountException(defaultInterpolatedStringHandler.ToStringAndClear());
}
array4[k] = testCaseParameters.Arguments[k];
}
}
testCaseParameters.Arguments = array4;
}
if (num == 1 && method.GetParameters()[0].ParameterType == typeof(object[]) && (num2 > 1 || (num2 == 1 && testCaseParameters.Arguments[0]?.GetType() != typeof(object[]))))
testCaseParameters.Arguments = new object[1] {
testCaseParameters.Arguments
};
if (num2 != num)
return testCaseParameters;
PerformSpecialConversions(testCaseParameters.Arguments, parameters);
return testCaseParameters;
} catch (Exception exception) {
return new TestCaseParameters(exception);
}
}
[NullableContext(1)]
private static void PerformSpecialConversions([Nullable(new byte[] {
1,
2
})] object[] arglist, IParameterInfo[] parameters)
{
for (int i = 0; i < arglist.Length; i++) {
object value = arglist[i];
Type parameterType = parameters[i].ParameterType;
if (ParamAttributeTypeConversions.TryConvert(value, parameterType, out object convertedValue))
arglist[i] = convertedValue;
}
}
[NullableContext(1)]
[IteratorStateMachine(typeof(<BuildFrom>d__70))]
public IEnumerable<TestMethod> BuildFrom(IMethodInfo method, [Nullable(2)] Test suite)
{
<BuildFrom>d__70 <BuildFrom>d__ = new <BuildFrom>d__70(-2);
<BuildFrom>d__.<>4__this = this;
<BuildFrom>d__.<>3__method = method;
<BuildFrom>d__.<>3__suite = suite;
return <BuildFrom>d__;
}
}
}