public void PropertyValueProviderFqn()
{
var tc = new TestCase("Test1", new Uri("executor://NUnitTestExecutor"), "NUnit.VSIX");
var testFilter = new TFSTestFilter(null);
var obj = TFSTestFilter.PropertyValueProvider(tc, "FullyQualifiedName");
Assert.AreSame("Test1", obj);
}
public void Buy()
{
var test = new TestCase();
test.Buyer.Bank = 10000;
Auction auction = test.CreateAuction();
Assert.AreEqual(1000, auction.Quantity);
uint auctionQuantity = auction.Quantity;
IItem item;
while (auctionQuantity > 100)
{
item = test.Buyer.Buy(auction, 100);
auctionQuantity -= 100;
Assert.AreEqual(auctionQuantity, auction.Quantity);
Assert.AreEqual(100, item.Quantity);
Assert.AreEqual(test.Buyer, item.Owner);
Assert.AreEqual(2, test.Buyer.Assets.Count);
}
item = test.Buyer.Buy(auction, 100);
Assert.AreEqual(test.Buyer, item.Owner);
CollectionAssert.DoesNotContain(test.Seller.Assets, auction.Item);
Assert.AreEqual(2, test.Buyer.Assets.Count);
Assert.AreEqual(1, test.Seller.Assets.Count);
}
public static void CheckHits_(Query query, System.String defaultFieldName, Searcher searcher, int[] results, TestCase testCase)
{
Hits hits = searcher.Search(query);
System.Collections.Hashtable correct = new System.Collections.Hashtable();
for (int i = 0; i < results.Length; i++)
{
correct.Add((System.Int32) results[i], null);
}
System.Collections.Hashtable actual = new System.Collections.Hashtable();
for (int i = 0; i < hits.Length(); i++)
{
actual.Add((System.Int32) hits.Id(i), null);
}
//Assert.AreEqual(correct, actual, query.ToString(defaultFieldName));
if (correct.Count != 0)
{
System.Collections.IDictionaryEnumerator iter = correct.GetEnumerator();
bool status = false;
while (iter.MoveNext())
{
status = actual.ContainsKey(iter.Key);
if (status == false)
break;
}
Assert.IsTrue(status, query.ToString(defaultFieldName));
}
}
public void ExceptionHandlerIsCalledWhenExceptionMatches_AlternateHandler()
{
ExceptionHandlerCalledClass fixture = new ExceptionHandlerCalledClass();
ITest testCase = new TestCase("ThrowsArgumentException_AlternateHandler", fixture);
testCase.Run();
Assert.That(fixture.HandlerCalled, Is.False, "Base Handler should not be called");
Assert.That(fixture.AlternateHandlerCalled, "Alternate Handler should be called");
}
public void ExceptionHandlerIsNotCalledWhenExceptionDoesNotMatch()
{
ExceptionHandlerCalledClass fixture = new ExceptionHandlerCalledClass();
ITest testCase = new TestCase("ThrowsApplicationException", fixture);
testCase.Run();
Assert.That(fixture.HandlerCalled, Is.False, "Base Handler should not be called");
Assert.That(fixture.AlternateHandlerCalled, Is.False, "Alternate Handler should not be called");
}
public void PropertyValueProviderCategoryFail()
{
var tc = new TestCase("Test1", new Uri("executor://NUnitTestExecutor"), "NUnit.VSIX");
tc.AddTrait("Category", "CI");
var testFilter = new TFSTestFilter(null);
var obj = TFSTestFilter.PropertyValueProvider(tc, "Garbage");
Assert.Null(obj);
}
public void CreateAuction()
{
var test = new TestCase();
Auction auction = test.CreateAuction();
Assert.AreEqual(test.Seller, auction.Owner);
CollectionAssert.DoesNotContain(test.Seller.Assets, auction.Item);
}
public void PropertyValueProviderCategoryWithNoTraits()
{
CheckTraitsSupported();
var tc = new TestCase("Test1", new Uri("executor://NUnitTestExecutor"), "NUnit.VSIX");
var testFilter = new TFSTestFilter(null);
var obj = TFSTestFilter.PropertyValueProvider(tc, "TestCategory");
Assert.IsNull(obj);
}
public void TestTextManipulationWithMnemonicNoEllipsing(TestCase testCase)
{
DecentGroupBoxWrapper gb = new DecentGroupBoxWrapper { Width = testCase.Width, UseMnemonic = true, AutoEllipsis = false};
gb.Text = testCase.Text;
Assert.IsFalse(gb.AutoEllipsis, "auto ellipse setting");
Assert.IsTrue(gb.UseMnemonic, "use mnemonic setting");
Assert.That(gb.Text, Is.EqualTo(testCase.Text), "Raw text TestCase: " + testCase.Text);
Assert.That(gb.ManipulatedText, Is.EqualTo(testCase.Expected), "Manipulated text TestCase: " + testCase.Text);
}
public void FailsWhenAlternateHandlerIsNotFound()
{
ExceptionHandlerCalledClass fixture = new ExceptionHandlerCalledClass();
ITest testCase = new TestCase("MethodWithBadHandler", fixture);
TestResult result = testCase.Run();
Assert.That(result.ResultState, Is.EqualTo(ResultState.Failure));
Assert.That(result.Message, Is.EqualTo(
"The specified exception handler DeliberatelyMissingHandler was not found" ));
}
public void CanRegisterEvents()
{
var sw = new StringWriter();
var testCase =new TestCase(sw);
var eventData = new TestEvent {Name = "Hello"};
EventManager.Register<TestEvent>(testCase.ProcessEvent);
EventManager.Raise(eventData);
Assert.AreEqual(sw.ToString(), eventData.Name);
}
public void PropertyValueProviderCategoryWithOneCategory()
{
CheckTraitsSupported();
var tc = new TestCase("Test1", new Uri("executor://NUnitTestExecutor"), "NUnit.VSIX");
tc.AddTrait("Category", "CI");
var testFilter = new TFSTestFilter(null);
var obj = TFSTestFilter.PropertyValueProvider(tc, "TestCategory");
Assert.AreSame("CI", obj);
}
/// <summary>
/// Parameterised unit test for <cref>SortingAlgorithmModule.SortThatWorks</cref>.
/// </summary>
/// <remarks>
/// This is expected to succeed.
/// </remarks>
/// <param name="testCase"></param>
public static void ParameterisedUnitTestForReassemblyOfPermutedMonotonicIncreasingSequenceByCorrectSortingAlgorithm(TestCase testCase)
{
Console.WriteLine("[{0}]", String.Join(", ", testCase.PermutedSequence));
var sortedSequence =
SortingAlgorithmModule.SortThatWorks(testCase.PermutedSequence);
Assert.IsTrue(
sortedSequence.SequenceEqual(testCase.OriginalMonotonicIncreasingSequence));
}
public void MultipleSubscribersAreCalled()
{
var sw = new StringWriter();
var testCase = new TestCase(sw);
var testCase2 = new TestCase(sw);
var eventData = new TestEvent { Name = "Hello" };
EventManager.Register<TestEvent>(testCase.ProcessEvent);
EventManager.Register<TestEvent>(testCase2.ProcessEvent);
EventManager.Raise(eventData);
Assert.AreEqual(sw.ToString(), eventData.Name + eventData.Name);
}
public void ExpireAuction()
{
var test = new TestCase();
Auction auction = test.CreateAuction();
Assert.AreEqual(test.Seller, auction.Owner);
CollectionAssert.DoesNotContain(test.Seller.Assets, auction.Item);
while (auction.Expires > 0)
test.Universe.Tick();
CollectionAssert.Contains(test.Seller.Assets, auction.Item);
}
public void PropertyValueProviderCategoryWithMultipleCategories()
{
CheckTraitsSupported();
var tc = new TestCase("Test1", new Uri("executor://NUnitTestExecutor"), "NUnit.VSIX");
tc.AddTrait("Category", "CI");
tc.AddTrait("Category", "MyOwn");
var testFilter = new TFSTestFilter(null);
var obj = TFSTestFilter.PropertyValueProvider(tc, "TestCategory") as string[];
Assert.IsNotNull(obj);
Assert.AreEqual(obj.Length,2);
Assert.AreSame("CI", obj[0]);
Assert.AreSame("MyOwn",obj[1]);
}
public void BuyPartial()
{
var test = new TestCase();
test.Buyer.Bank = 10000;
Auction auction = test.CreateAuction();
Assert.AreEqual(1000, auction.Quantity);
IItem item = test.Buyer.Buy(auction, 100);
Assert.AreEqual(100, item.Quantity);
Assert.AreEqual(test.Buyer, item.Owner);
CollectionAssert.Contains(test.Buyer.Assets, item);
}
private void CheckTestCase(TestCase testCase)
{
Assert.That(testCase.FullyQualifiedName, Is.EqualTo(FakeTestData.FullyQualifiedName));
Assert.That(testCase.DisplayName, Is.EqualTo(FakeTestData.DisplayName));
Assert.That(testCase.Source, Is.SamePath(FakeTestData.AssemblyPath));
Assert.That(testCase.CodeFilePath, Is.SamePath(FakeTestData.CodeFile));
Assert.That(testCase.LineNumber, Is.EqualTo(FakeTestData.LineNumber));
// Check traits using reflection, since the feature was added
// in an update to VisualStudio and may not be present.
if (TraitsFeature.IsSupported)
{
var traitList = testCase.GetTraits().Select(trait => trait.Name + ":" + trait.Value).ToList();
Assert.That(traitList, Is.EquivalentTo(new[] { "Category:super", "Category:cat1", "Priority:medium" }));
}
}
public void TestThatTestCaseWithUnspecifiedOriginFindsOriginAssemblyInTestMethod()
{
var tc = new TestCase(_testCase.TestMethod, new MSTestTestFramework().AsRelated());
Assert.AreSame(tc.TestMethod.Module.Assembly, _testCase.Origin.Assembly);
}
public void StringBasedRepsonsesToRowState(TestCase tc)
{
Mock<SummaryTextComponent> baseComponent = new Mock<SummaryTextComponent>();
StringBuilder sb = new StringBuilder();
baseComponent.Setup(c => c.BuildSummary()).Returns(sb);
Mock<Host> host = ObjectFactory.BuiltObject<Host>(ObjectBuilderType.ClearwaterHost, id);
Mock<ILicenseStatus> ls = new Mock<ILicenseStatus>();
ls.Setup(l => l.CurrentState).Returns(tc.State);
ls.Setup(l =>l.ExpiryDate).Returns(tc.Expiry);
ls.Setup(l => l.LicenseExpiresIn).Returns(tc.ExpiresIn);
CheckableDataGridViewRow row = new LicenseDataGridViewRow(host.Object, ls.Object);
LicenseManagerSummaryLicenseExpiresDecorator decorator = new LicenseManagerSummaryLicenseExpiresDecorator(baseComponent.Object, row);
decorator.BuildSummary();
Assert.That(sb.ToString().Contains(Messages.LICENSE_MANAGER_SUMMARY_LICENSE_EXPIRES));
Assert.That(sb.ToString().Contains(tc.Contains));
baseComponent.Verify(c=>c.BuildSummary(), Times.Once());
}
private void checkMac(IMac mac, TestCase testCase)
{
byte[] generatedMac = new byte[mac.GetMacSize()];
mac.DoFinal(generatedMac, 0);
if (!AreEqual(testCase.getTag(), generatedMac))
{
Fail("Failed " + testCase.getName() + " - expected " + Hex.ToHexString(testCase.getTag()) + " got "
+ Hex.ToHexString(generatedMac));
}
}
private void testSingleByte(IMac mac, TestCase testCase)
{
byte[] ad = testCase.getAd();
for (int i = 0; i < ad.Length; i++)
{
mac.Update(ad[i]);
}
checkMac(mac, testCase);
}
private void testMultibyte(IMac mac, TestCase testCase)
{
mac.BlockUpdate(testCase.getAd(), 0, testCase.getAd().Length);
checkMac(mac, testCase);
}
public void TestXvaValidation(TestCase tc)
{
ApplianceExistsCheckStaticOverrides checker = new ApplianceExistsCheckStaticOverrides(directoryName, fileName, ApplianceCheck.FileExtension.xva)
{
DirectoryExistsValue = tc.DirFound,
FileExistsValue = tc.FileFound
};
checker.Validate();
Assert.That(checker.IsValid, Is.EqualTo(tc.Valid), "Is valid test -> " + tc);
Assert.That(checker.DirectoryExistsCalls, Is.EqualTo(0), "dir exists calls -> " + tc);
Assert.That(checker.FileExistsCalls, Is.EqualTo(1), "file exists calls -> " + tc);
}
/// <summary>
/// Assert that a 'TestSuite' trait with the provided value exists.
/// </summary>
/// <param name="testCase">The testcase which contains the trait collection in question</param>
/// <param name="value">The test suite value the looked-up trait should have</param>
private void AssertTestSuite(TestCase testCase, string value)
{
AssertTrait(testCase, VSTestModel.TestSuiteTrait, value);
}
/// <summary>
/// Assert that a trait with the provided name and value exists.
/// </summary>
/// <param name="testCase">The testcase which contains the trait collection in question</param>
/// <param name="name">The name of the trait to look for</param>
/// <param name="value">The value the looked-up trait should have</param>
private void AssertTrait(TestCase testCase, string name, string value)
{
Assert.That(testCase.Traits.Any((trait) => { return (trait.Name == name) && (trait.Value == value); }), Is.True);
}
/// <summary>
/// Asserts general test case details
/// </summary>
/// <param name="testCase">The test case to test</param>
/// <param name="qualifiedName">The expected qualified name of the test case</param>
/// <param name="sourceFile">The expected source file path of the test case or null if not available</param>
/// <param name="lineNumber">The expected line number of the test case or -1 if not available</param>
private void AssertTestDetails(TestCase testCase, QualifiedNameBuilder qualifiedName, string sourceFile, int lineNumber)
{
Assert.That(testCase.DisplayName, Is.EqualTo(qualifiedName.Peek()));
Assert.That(testCase.FullyQualifiedName, Is.EqualTo(qualifiedName.ToString()));
string suite = qualifiedName.Pop().ToString();
if (!string.IsNullOrEmpty(suite))
{
AssertTestSuite(testCase, suite);
}
else
{
// The default 'Master Test Suite' trait value should be available
AssertTrait(testCase, VSTestModel.TestSuiteTrait);
}
if (!string.IsNullOrEmpty(sourceFile))
{
Assert.That(testCase.CodeFilePath, Is.EqualTo(sourceFile));
}
if (lineNumber > -1)
{
Assert.That(testCase.LineNumber, Is.EqualTo(lineNumber));
}
}
public void FindFirstTestCase()
{
_testCase = TestHelper.FindTestCase<IntegerCalculatorTest>(t => t.TestAddBasic());
}
public void TestThatTestCaseExposesFramework()
{
var tc = new TestCase(_testCase.TestMethod, new MSTestTestFramework().AsRelated());
Assert.IsInstanceOf<MSTestTestFramework>(tc.Framework);
}
/// <summary>
/// Asserts general test case details
/// </summary>
/// <param name="testCase">The test case to test</param>
/// <param name="qualifiedName">The expected qualified name of the test case</param>
private void AssertTestDetails(TestCase testCase, QualifiedNameBuilder qualifiedName)
{
AssertTestDetails(testCase, qualifiedName, null, -1);
}