NUnit有一个称为Values的功能，如下所示:
[Test]
public void MyTest(
[Values(1,2,3)] int x,
[Values("A","B")] string s)
{
// ...
}
这意味着测试方法将运行六次：
MyTest(1, "A")
MyTest(1, "B")
MyTest(2, "A")
MyTest(2, "B")
MyTest(3, "A")
MyTest(3, "B")
我们现在正在使用MSTest，但是否有类似的工具可以让我使用多个参数运行相同的测试呢？
[TestMethod]
public void Mytest()
{
// ...
}
编辑4: 看起来这个功能已经在2016年6月17日的MSTest V2中完成了: https://blogs.msdn.microsoft.com/visualstudioalm/2016/06/17/taking-the-mstest-framework-forward-with-mstest-v2/
原始回答:
截至一周前，在Visual Studio 2012 Update 1中现在可以实现类似的事情:
[DataTestMethod]
[DataRow(12,3,4)]
[DataRow(12,2,6)]
[DataRow(12,4,3)]
public void DivideTest(int n, int d, int q)
{
Assert.AreEqual( q, n / d );
}
编辑: 看起来这仅适用于 WinRT/Metro 的单元测试项目。遗憾。
编辑 2: 在 Visual Studio 中使用“转到定义”找到的元数据如下:
#region Assembly Microsoft.VisualStudio.TestPlatform.UnitTestFramework.dll, v11.0.0.0
// C:\Program Files (x86)\Microsoft SDKs\Windows\v8.0\ExtensionSDKs\MSTestFramework\11.0\References\CommonConfiguration\neutral\Microsoft.VisualStudio.TestPlatform.UnitTestFramework.dll
#endregion
using System;
namespace Microsoft.VisualStudio.TestPlatform.UnitTestFramework
{
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class DataTestMethodAttribute : TestMethodAttribute
{
public DataTestMethodAttribute();
public override TestResult[] Execute(ITestMethod testMethod);
}
}
编辑3：此问题曾在Visual Studio的UserVoice论坛上被提出。 最新更新如下：
开始 · Visual Studio团队管理员Visual Studio Team（产品团队，Microsoft Visual Studio）已回复 · 2016年4月25日感谢您的反馈。我们已经开始着手解决此问题。
Pratap Lakshman Visual Studio
[TestClass]
public class UnitTest1
{
[TestMethod]
[DataRow(1, 2, 2)]
[DataRow(2, 3, 5)]
[DataRow(3, 5, 8)]
public void AdditionTest(int a, int b, int result)
{
Assert.AreEqual(result, a + b);
}
}
[DataRow(1, 2, 3)] ?? - JohnBa、b 和 result。 - timelmer[DataRow(1, 2, 3)]。 - JohnB很遗憾，较早版本的MSTest不支持此功能。显然，有一个可扩展模型，您可以自己实现。另一个选择是使用数据驱动测试。
我的个人意见是坚持使用NUnit ...
从Visual Studio 2012更新1开始，MSTest具有类似的功能。请参见McAden's answer。
虽然与NUnit的Value（或TestCase）属性不完全相同，但MSTest具有DataSource属性，可以让您执行类似的操作。
您可以将其连接到数据库或XML文件-它不像NUnit的功能那样直接，但它可以完成工作。
MSTest有一个强大的属性叫做DataSource。使用它，您可以执行数据驱动测试，就像您所要求的那样。您可以将测试数据存储在XML、CSV或数据库中。以下是一些指南链接：
我在 Visual Studio 2015 中无法使用 DataRowAttribute，最终采用了以下方法：
[TestClass]
public class Tests
{
private Foo _toTest;
[TestInitialize]
public void Setup()
{
this._toTest = new Foo();
}
[TestMethod]
public void ATest()
{
this.Perform_ATest(1, 1, 2);
this.Setup();
this.Perform_ATest(100, 200, 300);
this.Setup();
this.Perform_ATest(817001, 212, 817213);
this.Setup();
}
private void Perform_ATest(int a, int b, int expected)
{
// Obviously this would be way more complex...
Assert.IsTrue(this._toTest.Add(a,b) == expected);
}
}
public class Foo
{
public int Add(int a, int b)
{
return a + b;
}
}
真正的解决方案是使用NUnit（除非您像我一样在这种特殊情况下被困在MSTest中）。
这很容易实现 - 你应该使用TestContext属性和TestPropertyAttribute。
public TestContext TestContext { get; set; }
private List<string> GetProperties()
{
return TestContext.Properties
.Cast<KeyValuePair<string, object>>()
.Where(_ => _.Key.StartsWith("par"))
.Select(_ => _.Value as string)
.ToList();
}
//usage
[TestMethod]
[TestProperty("par1", "http://getbootstrap.com/components/")]
[TestProperty("par2", "http://www.wsj.com/europe")]
public void SomeTest()
{
var pars = GetProperties();
//...
}
我准备了一些扩展方法来简化访问TestContext属性，就像我们拥有多个测试用例一样。请看这里处理简单测试属性的示例：
[TestMethod]
[TestProperty("fileName1", @".\test_file1")]
[TestProperty("fileName2", @".\test_file2")]
[TestProperty("fileName3", @".\test_file3")]
public void TestMethod3()
{
TestContext.GetMany<string>("fileName").ForEach(fileName =>
{
//Arrange
var f = new FileInfo(fileName);
//Act
var isExists = f.Exists;
//Asssert
Assert.IsFalse(isExists);
});
}
[TestMethod]
//Case 1
[TestProperty(nameof(FileDescriptor.FileVersionId), "673C9C2D-A29E-4ACC-90D4-67C52FBA84E4")]
//...
public void TestMethod2()
{
//Arrange
TestContext.For<FileDescriptor>().Fill(fi => fi.FileVersionId).Fill(fi => fi.Extension).Fill(fi => fi.Name).Fill(fi => fi.CreatedOn, new CultureInfo("en-US", false)).Fill(fi => fi.AccessPolicy)
.ForEach(fileInfo =>
{
//Act
var fileInfoString = fileInfo.ToString();
//Assert
Assert.AreEqual($"Id: {fileInfo.FileVersionId}; Ext: {fileInfo.Extension}; Name: {fileInfo.Name}; Created: {fileInfo.CreatedOn}; AccessPolicy: {fileInfo.AccessPolicy};", fileInfoString);
});
}
当然，还有另一种方法可以实现这个功能，这在本主题中没有讨论过，即通过继承包含TestMethod的类来实现。在下面的例子中，只定义了一个TestMethod，但是制作了两个测试用例。
在Visual Studio 2012中，它会在TestExplorer中创建两个测试：
DemoTest_A12_B4.test
public class Demo
{
int a, b;
public Demo(int _a, int _b)
{
this.a = _a;
this.b = _b;
}
public int Sum()
{
return this.a + this.b;
}
}
public abstract class DemoTestBase
{
Demo objUnderTest;
int expectedSum;
public DemoTestBase(int _a, int _b, int _expectedSum)
{
objUnderTest = new Demo(_a, _b);
this.expectedSum = _expectedSum;
}
[TestMethod]
public void test()
{
Assert.AreEqual(this.expectedSum, this.objUnderTest.Sum());
}
}
[TestClass]
public class DemoTest_A12_B4 : DemoTestBase
{
public DemoTest_A12_B4() : base(12, 4, 16) { }
}
public abstract class DemoTest_B10_Base : DemoTestBase
{
public DemoTest_B10_Base(int _a) : base(_a, 10, _a + 10) { }
}
[TestClass]
public class DemoTest_B10_A5 : DemoTest_B10_Base
{
public DemoTest_B10_A5() : base(5) { }
}
#nullable enable
public enum ValuesType
{
Undefined = 0,
Cartesian = 1,
/// <summary>
/// Values will be <see cref="Enumerable.Zip{TFirst, TSecond, TResult}(IEnumerable{TFirst}, IEnumerable{TSecond}, Func{TFirst, TSecond, TResult})">Zipped</see> with the cartesian produce of the other parameters.
/// </summary>
Zip = 2
}
[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false)]
public class ValuesAttribute : Attribute
{
public ValuesType ValuesType { get; }
public object[] Values { get; }
public ValuesAttribute(params object[] values)
: this(ValuesType.Cartesian, values)
{ }
public ValuesAttribute(ValuesType valuesType, params object[] values)
{
ValuesType = valuesType;
Values = values;
}
}
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class ValuesDataSourceAttribute : Attribute, ITestDataSource
{
public IEnumerable<object[]> GetData(MethodInfo methodInfo)
{
var parameters = methodInfo.GetParameters();
var values = new (ValuesType Type, object[] Values, int Index)[parameters.Length];
for(var i=0; i < parameters.Length; i++)
{
var parameter = parameters[i];
var attribute = parameter.GetCustomAttribute<ValuesAttribute>();
if (attribute != null)
{
if (attribute.Values.Any(v => !parameter.ParameterType.IsAssignableFrom(v.GetType())))
throw new InvalidOperationException($"All values of {nameof(ValuesAttribute)} must be of type {parameter.ParameterType.Name}. ParameterName: {parameter.Name}.");
switch (attribute.ValuesType)
{
case ValuesType.Cartesian:
values[i] = (ValuesType.Cartesian, attribute.Values, 0);
break;
case ValuesType.Zip:
values[i] = (ValuesType.Zip, attribute.Values, 0);
break;
}
}
else if (parameter.ParameterType == typeof(bool))
values[i] = (ValuesType.Cartesian, new object[] { false, true }, 0);
else if (parameter.ParameterType.IsEnum)
values[i] = (ValuesType.Cartesian, Enum.GetValues(parameter.ParameterType).Cast<Object>().ToArray(), 0);
else
throw new InvalidOperationException($"All parameters must have either {nameof(ValuesAttribute)} attached or be a bool or an Enum . ParameterName: {parameter.Name}.");
}
//Since we are using ValueTuples, it is essential that once we created our collection, we stick to it. If we were to create a new one, we would end up with a copy of the ValueTuples that won't be synced anymore.
var cartesianTotalCount = values.Where(v => v.Type == ValuesType.Cartesian).Aggregate(1, (actualTotal, currentValues) => actualTotal * currentValues.Values.Length);
if (values.Any(v => v.Type == ValuesType.Zip && v.Values.Length != cartesianTotalCount))
throw new InvalidOperationException($"{nameof(ValuesType.Zip)} typed attributes must have as many values as the produce of all the others ({cartesianTotalCount}).");
bool doIncrement;
for(var globalPosition = 0; globalPosition < cartesianTotalCount; globalPosition++)
{
yield return values.Select(v => v.Values[v.Index]).ToArray();
doIncrement = true;
for (var i = values.Length - 1; i >= 0 && doIncrement; i--)
{
switch (values[i].Type)
{
case ValuesType.Zip:
values[i].Index++;
break;
case ValuesType.Cartesian:
if (doIncrement && ++values[i].Index >= values[i].Values.Length)
values[i].Index = 0;
else
doIncrement = false;
break;
default:
throw new InvalidOperationException($"{values[i].Type} is not supported.");
}
}
}
}
public string GetDisplayName(MethodInfo methodInfo, object[] data)
{
return data.JoinStrings(" / ");
}
}
使用方法：
[TestMethod]
[ValuesDataSource]
public void Test([Values("a1", "a2")] string a, [Values(1, 2)] int b, bool c, System.ConsoleModifiers d, [Values(ValuesType.Zip, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24)] int asserts)
{
//Arrange / Act / Assert
//Cases would be
// a1, 1, false, System.ConsoleModifiers.Alt, 1
// a1, 1, false, System.ConsoleModifiers.Shift, 2
// a1, 1, false, System.ConsoleModifiers.Control, 3
// a1, 1, true, System.ConsoleModifiers.Alt, 4
// a1, 1, true, System.ConsoleModifiers.Shift, 5
// a1, 1, true, System.ConsoleModifiers.Control, 6
// a1, 2, false, System.ConsoleModifiers.Alt, 7
// a1, 2, false, System.ConsoleModifiers.Shift, 8
// a1, 2, false, System.ConsoleModifiers.Control, 9
// a1, 2, true, System.ConsoleModifiers.Alt, 10
// a1, 2, true, System.ConsoleModifiers.Shift, 11
// a1, 2, true, System.ConsoleModifiers.Control, 12
// a2, 1, false, System.ConsoleModifiers.Alt, 13
// a2, 1, false, System.ConsoleModifiers.Shift, 14
// a2, 1, false, System.ConsoleModifiers.Control, 15
// a2, 1, true, System.ConsoleModifiers.Alt, 16
// a2, 1, true, System.ConsoleModifiers.Shift, 17
// a2, 1, true, System.ConsoleModifiers.Control, 18
// a2, 2, false, System.ConsoleModifiers.Alt, 19
// a2, 2, false, System.ConsoleModifiers.Shift, 20
// a2, 2, false, System.ConsoleModifiers.Control, 21
// a2, 2, true, System.ConsoleModifiers.Alt, 22
// a2, 2, true, System.ConsoleModifiers.Shift, 23
// a2, 2, true, System.ConsoleModifiers.Control, 24
}