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.Builders;
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
{
[System.Runtime.CompilerServices.NullableContext(2)]
[System.Runtime.CompilerServices.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; }
[System.Runtime.CompilerServices.Nullable(new byte[] {
1,
2
})]
[field: System.Runtime.CompilerServices.Nullable(new byte[] {
1,
2
})]
public object[] Arguments {
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
1,
2
})]
get;
}
[System.Runtime.CompilerServices.Nullable(1)]
[field: System.Runtime.CompilerServices.Nullable(1)]
public IPropertyBag Properties {
[System.Runtime.CompilerServices.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; }
[System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})]
[field: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})]
public Type[] TypeArgs {
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})]
get;
[param: System.Runtime.CompilerServices.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();
}
[System.Runtime.CompilerServices.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);
}
}
[System.Runtime.CompilerServices.NullableContext(1)]
private static void PerformSpecialConversions([System.Runtime.CompilerServices.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;
}
}
[System.Runtime.CompilerServices.NullableContext(1)]
public IEnumerable<TestMethod> BuildFrom(IMethodInfo method, [System.Runtime.CompilerServices.Nullable(2)] Test suite)
{
TestMethod testMethod = new NUnitTestCaseBuilder().BuildTestMethod(method, suite, GetParametersForTestCase(method));
if (_untilDate.HasValue) {
if (_untilDate > (DateTimeOffset?)DateTimeOffset.UtcNow) {
testMethod.RunState = RunState.Ignored;
DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(17, 2);
defaultInterpolatedStringHandler.AppendLiteral("Ignoring until ");
defaultInterpolatedStringHandler.AppendFormatted(_untilDate.Value, "u");
defaultInterpolatedStringHandler.AppendLiteral(". ");
defaultInterpolatedStringHandler.AppendFormatted(IgnoreReason);
string value = defaultInterpolatedStringHandler.ToStringAndClear();
testMethod.Properties.Set("_SKIPREASON", value);
} else
testMethod.RunState = _originalRunState;
}
if (IncludePlatform != null || ExcludePlatform != null) {
RunState runState = testMethod.RunState;
if ((runState == RunState.NotRunnable || runState == RunState.Ignored) ? true : false) {
yield return testMethod;
yield break;
}
PlatformHelper platformHelper = new PlatformHelper();
if (!platformHelper.IsPlatformSupported(this)) {
testMethod.RunState = RunState.Skipped;
testMethod.Properties.Add("_SKIPREASON", platformHelper.Reason);
}
}
yield return testMethod;
}
}
}