public void ExecuteShouldKillTheThreadExecutingAsyncOnTimeout() { ManualResetEvent timeoutMutex = new ManualResetEvent(false); var hasReachedEnd = false; var isThreadAbortThrown = false; Action action = () => { try { timeoutMutex.WaitOne(); hasReachedEnd = true; } catch (ThreadAbortException) { isThreadAbortThrown = true; // Resetting abort because there is a warning being thrown in the tests pane. Thread.ResetAbort(); } }; Assert.IsFalse(this.asyncOperations.Execute(action, 1)); timeoutMutex.Set(); Assert.IsFalse(hasReachedEnd); Assert.IsTrue(isThreadAbortThrown); }
public void PopulateSettingsShouldFillInSettingsFromSettingsObject() { string runsettingsXml = @"<RunSettings> <MSTest> <CaptureTraceOutput>False</CaptureTraceOutput> <MapInconclusiveToFailed>True</MapInconclusiveToFailed> <MapNotRunnableToFailed>True</MapNotRunnableToFailed> <SettingsFile>DummyPath\\TestSettings1.testsettings</SettingsFile> <ForcedLegacyMode>true</ForcedLegacyMode> <EnableBaseClassTestMethodsFromOtherAssemblies>true</EnableBaseClassTestMethodsFromOtherAssemblies> <TreatClassAndAssemblyCleanupWarningsAsErrors>true</TreatClassAndAssemblyCleanupWarningsAsErrors> </MSTest> </RunSettings>"; var settings = MSTestSettings.GetSettings(runsettingsXml, MSTestSettings.SettingsName); MSTestSettings.PopulateSettings(settings); Assert.IsFalse(MSTestSettings.CurrentSettings.CaptureDebugTraces); Assert.IsTrue(MSTestSettings.CurrentSettings.MapInconclusiveToFailed); Assert.IsTrue(MSTestSettings.CurrentSettings.MapNotRunnableToFailed); Assert.IsTrue(MSTestSettings.CurrentSettings.ForcedLegacyMode); Assert.IsTrue(MSTestSettings.CurrentSettings.EnableBaseClassTestMethodsFromOtherAssemblies); Assert.IsTrue(MSTestSettings.CurrentSettings.TreatClassAndAssemblyCleanupWarningsAsErrors); Assert.IsFalse(string.IsNullOrEmpty(MSTestSettings.CurrentSettings.TestSettingsFile)); }
public void TestClassInfoHasExecutableCleanupMethodShouldReturnFalseIfClassInitializeThrowsAnException() { this.testClassInfo.ClassCleanupMethod = this.testClassType.GetMethods().First(); this.testClassInfo.ClassInitializationException = new NotImplementedException(); Assert.IsFalse(this.testClassInfo.HasExecutableCleanupMethod); }
public void PopulateSettingsShouldInitializeSettingsFromMSTestSection() { string runSettingxml = @"<RunSettings> <MSTest> <MapInconclusiveToFailed>True</MapInconclusiveToFailed> <MapNotRunnableToFailed>True</MapNotRunnableToFailed> <SettingsFile>DummyPath\\TestSettings1.testsettings</SettingsFile> <ForcedLegacyMode>true</ForcedLegacyMode> <EnableBaseClassTestMethodsFromOtherAssemblies>true</EnableBaseClassTestMethodsFromOtherAssemblies> </MSTest> </RunSettings>"; this.mockDiscoveryContext.Setup(dc => dc.RunSettings).Returns(this.mockRunSettings.Object); this.mockRunSettings.Setup(rs => rs.SettingsXml).Returns(runSettingxml); MSTestSettings.PopulateSettings(this.mockDiscoveryContext.Object); var adapterSettings = MSTestSettings.CurrentSettings; Assert.IsNotNull(adapterSettings); Assert.IsTrue(adapterSettings.MapInconclusiveToFailed); Assert.IsTrue(adapterSettings.MapNotRunnableToFailed); Assert.IsTrue(adapterSettings.ForcedLegacyMode); Assert.IsTrue(adapterSettings.EnableBaseClassTestMethodsFromOtherAssemblies); Assert.IsFalse(string.IsNullOrEmpty(adapterSettings.TestSettingsFile)); }
public void DeployShouldReturnFalseWhenNoDeploymentItemsOnTestCase() { var testCase = new TestCase("A.C.M", new System.Uri("executor://testExecutor"), "A"); testCase.SetPropertyValue(DeploymentItemUtilityTests.DeploymentItemsProperty, null); var testRunDirectories = new TestRunDirectories(RootDeploymentDirectory); this.mockFileUtility.Setup(fu => fu.DoesDirectoryExist(It.Is <string>(s => !(s.EndsWith(".dll") || s.EndsWith(".config"))))).Returns(true); this.mockFileUtility.Setup(fu => fu.DoesFileExist(It.IsAny <string>())).Returns(true); this.mockAssemblyUtility.Setup( au => au.GetFullPathToDependentAssemblies(It.IsAny <string>(), It.IsAny <string>(), out this.warnings)) .Returns(new string[] { }); this.mockAssemblyUtility.Setup( au => au.GetSatelliteAssemblies(It.IsAny <string>())) .Returns(new List <string> { }); Assert.IsFalse( this.deploymentUtility.Deploy( new List <TestCase> { testCase }, testCase.Source, this.mockRunContext.Object, this.mocktestExecutionRecorder.Object, testRunDirectories)); }
public void IsValidTestMethodShouldReturnFalseForGenericTestMethods() { this.SetupTestMethod(); Action action = () => new DummyTestClassWithGenericMethods().GenericMethod <int>(); Assert.IsFalse(this.testMethodValidator.IsValidTestMethod(action.Method, typeof(DummyTestClassWithGenericMethods), this.warnings)); }
public void ExecuteShouldKillTheThreadExecutingAsyncOnTimeout() { ManualResetEvent timeoutMutex = new ManualResetEvent(false); ManualResetEvent actionCompleted = new ManualResetEvent(false); var hasReachedEnd = false; var isThreadAbortThrown = false; var cancellationTokenSource = new CancellationTokenSource(); void action() { try { timeoutMutex.WaitOne(); hasReachedEnd = true; } catch (ThreadAbortException) { isThreadAbortThrown = true; // Resetting abort because there is a warning being thrown in the tests pane. Thread.ResetAbort(); } finally { actionCompleted.Set(); } } Assert.IsFalse(this.asyncOperations.Execute(action, 1, cancellationTokenSource.Token)); timeoutMutex.Set(); actionCompleted.WaitOne(); Assert.IsFalse(hasReachedEnd, "Execution Completed successfully"); Assert.IsTrue(isThreadAbortThrown, "ThreadAbortException not thrown"); }
public void CheckResolutionPathsDoNotContainPrivateAssembliesPathTest() { TestSourceHost isolatedHost = new TestSourceHost(null, null, null); List <string> paths = isolatedHost.GetResolutionPaths(Assembly.GetExecutingAssembly().FullName, true); Assert.IsFalse(paths.Contains(Constants.PublicAssemblies) || paths.Contains(Constants.PrivateAssemblies)); }
public void DeployShouldReturnFalseWhenDeploymentEnabledSetToTrueButHasNoDeploymentItems() { var testCase = new TestCase("A.C.M", new System.Uri("executor://testExecutor"), "A"); testCase.SetPropertyValue(DeploymentItemUtilityTests.DeploymentItemsProperty, null); var testDeployment = new TestDeployment( new DeploymentItemUtility(this.mockReflectionUtility.Object), new DeploymentUtility(), this.mockFileUtility.Object); string runSettingxml = @"<DeploymentEnabled>True</DeploymentEnabled>"; StringReader stringReader = new StringReader(runSettingxml); XmlReader reader = XmlReader.Create(stringReader, XmlRunSettingsUtilities.ReaderSettings); MSTestSettingsProvider mstestSettingsProvider = new MSTestSettingsProvider(); mstestSettingsProvider.Load(reader); // Deployment should not happen Assert.IsFalse(testDeployment.Deploy(new List <TestCase> { testCase }, null, null)); // Deployment directories should get created Assert.IsNotNull(testDeployment.GetDeploymentDirectory()); }
public void GetTestsShouldNotReturnHiddenTestMethodsFromAnyLevel() { this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameAssembly: true); TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummySecondHidingTestClass), Assembly.GetExecutingAssembly().FullName); var tests = typeEnumerator.Enumerate(out this.warnings); Assert.IsNotNull(tests); Assert.AreEqual( 1, tests.Count(t => t.TestMethod.Name == "BaseTestMethod"), "DummySecondHidingTestClass hides BaseTestMethod so it should be discovered."); Assert.AreEqual( 1, tests.Count(t => t.TestMethod.Name == "DerivedTestMethod"), "DummySecondHidingTestClass hides DerivedTestMethod so it should be discovered."); Assert.IsFalse( tests.Any(t => t.TestMethod.DeclaringClassFullName == typeof(DummyBaseTestClass).FullName), "DummySecondHidingTestClass hides all base test methods so declaring class should not be any base class"); Assert.IsFalse( tests.Any(t => t.TestMethod.DeclaringClassFullName == typeof(DummyHidingTestClass).FullName), "DummySecondHidingTestClass hides all base test methods so declaring class should not be any base class"); Assert.IsFalse( tests.Any(t => t.TestMethod.DeclaringClassFullName == typeof(DummyOverridingTestClass).FullName), "DummySecondHidingTestClass hides all base test methods so declaring class should not be any base class"); }
public void GetFilterExpressionForNullRunContextReturnsNull() { TestableTestExecutionRecorder recorder = new TestableTestExecutionRecorder(); var filterExpression = this.TestMethodFilter.GetFilterExpression(null, recorder, out var filterHasError); Assert.IsNull(filterExpression); Assert.IsFalse(filterHasError); }
public void IsValidDeploymentItemShouldReportWarningIfSourcePathIsEmpty() { string warning; Assert.IsFalse(this.deploymentItemUtility.IsValidDeploymentItem(string.Empty, this.defaultDeploymentItemOutputDirectory, out warning)); StringAssert.Contains(Resource.DeploymentItemPathCannotBeNullOrEmpty, warning); }
public void HasDeployItemsShouldReturnFalseForNoDeploymentItems() { TestCase testCase = new TestCase("A.C.M", new System.Uri("executor://testExecutor"), "A"); testCase.SetPropertyValue(DeploymentItemsProperty, null); Assert.IsFalse(this.deploymentItemUtility.HasDeploymentItems(testCase)); }
public void IsValidDeploymentItemShouldReportWarningIfDeploymentOutputDirectoryIsNull() { string warning; Assert.IsFalse(this.deploymentItemUtility.IsValidDeploymentItem(this.defaultDeploymentItemPath, null, out warning)); StringAssert.Contains(Resource.DeploymentItemOutputDirectoryCannotBeNull, warning); }
public void WhenInternalDiscoveryIsEnabledIsValidTestClassShouldReturnFalseForInaccessibleTestClasses() { var typeValidator = new TypeValidator(this.mockReflectHelper.Object, true); var inaccessibleClassType = Assembly.GetExecutingAssembly().GetTypes().First(t => t.Name == "InaccessiblePublicClass"); this.SetupTestClass(); Assert.IsFalse(typeValidator.IsValidTestClass(inaccessibleClassType, this.warnings)); }
public void IsValidTestMethodShouldReturnFalseForAbstractMethods() { this.SetupTestMethod(); var methodInfo = typeof(DummyTestClass).GetMethod( "AbstractTestMethod", BindingFlags.Instance | BindingFlags.Public); Assert.IsFalse(this.testMethodValidator.IsValidTestMethod(methodInfo, typeof(DummyTestClass), this.warnings)); }
public void IsValidTestMethodShouldReturnFalseForGenericTestMethodDefinitions() { this.SetupTestMethod(); this.mockMethodInfo.Setup(mi => mi.IsGenericMethodDefinition).Returns(true); this.mockMethodInfo.Setup(mi => mi.DeclaringType.FullName).Returns("DummyTestClass"); this.mockMethodInfo.Setup(mi => mi.Name).Returns("DummyTestMethod"); Assert.IsFalse(this.testMethodValidator.IsValidTestMethod(this.mockMethodInfo.Object, this.type, this.warnings)); }
public void IsValidTestMethodShouldReturnFalseForMethodsWithNonVoidReturnType() { this.SetupTestMethod(); var methodInfo = typeof(DummyTestClass).GetMethod( "MethodWithIntReturnType", BindingFlags.Instance | BindingFlags.Public); Assert.IsFalse(this.testMethodValidator.IsValidTestMethod(methodInfo, typeof(DummyTestClass), this.warnings)); }
public void TryGetPropertyValueShouldReturnFalseIfPropertyIsNotPresent() { this.testContextImplementation = new TestContextImplementation(this.testMethod.Object, new System.IO.StringWriter(), this.properties); object propValue; Assert.IsFalse(this.testContextImplementation.TryGetPropertyValue("Random", out propValue)); Assert.IsNull(propValue); }
public void GetFilterExpressionForDiscoveryContextWithoutGetTestCaseFilterReturnsNullTestCaseFilterExpression() { TestableTestExecutionRecorder recorder = new TestableTestExecutionRecorder(); TestableDiscoveryContextWithoutGetTestCaseFilter discoveryContext = new TestableDiscoveryContextWithoutGetTestCaseFilter(); var filterExpression = this.TestMethodFilter.GetFilterExpression(discoveryContext, recorder, out var filterHasError); Assert.IsNull(filterExpression); Assert.IsFalse(filterHasError); }
public void IsIgnoreAttributeOnTestClassReturnsFalseIfIgnoreIsNotSetOnTestClass() { this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameType: true); TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyTestClass), "DummyAssemblyName"); // Setup mocks this.mockReflectHelper.Setup(rh => rh.IsAttributeDefined(typeof(DummyTestClass), typeof(UTF.IgnoreAttribute), It.IsAny <bool>())).Returns(false); Assert.IsFalse(typeEnumerator.IsIgnoreAttributeOnTestClass); }
public void CurrentSettingShouldReturnDefaultSettingsIfNotSet() { MSTestSettings.Reset(); var adapterSettings = MSTestSettings.CurrentSettings; Assert.IsNotNull(adapterSettings); // Validating the default value of a random setting. Assert.IsFalse(adapterSettings.ForcedLegacyMode); }
public void IsUnitTestAssertExceptionReturnsFalseIfExceptionIsNotAssertException() { var exception = new NotImplementedException(); UTF.UnitTestOutcome outcome = UTF.UnitTestOutcome.Unknown; string exceptionMessage = null; StackTraceInformation stackTraceInfo = null; Assert.IsFalse(exception.TryGetUnitTestAssertException(out outcome, out exceptionMessage, out stackTraceInfo)); }
public void GetFilterExpressionForDiscoveryContextWithGetTestCaseFilterReturnsValidTestCaseFilterExpression() { TestableTestExecutionRecorder recorder = new TestableTestExecutionRecorder(); var dummyFilterExpression = new TestableTestCaseFilterExpression(); TestableDiscoveryContextWithGetTestCaseFilter discoveryContext = new TestableDiscoveryContextWithGetTestCaseFilter(() => dummyFilterExpression); var filterExpression = this.TestMethodFilter.GetFilterExpression(discoveryContext, recorder, out var filterHasError); Assert.AreEqual(dummyFilterExpression, filterExpression); Assert.IsFalse(filterHasError); }
public void AreValidSourcesShouldReturnFalseIfValidSourceExtensionsIsEmpty() { this.testablePlatformServiceProvider.MockTestSourceValidator.SetupGet(ts => ts.ValidSourceExtensions).Returns(new List <string> { }); MSTestDiscoverer discoverer = new MSTestDiscoverer(); Assert.IsFalse(discoverer.AreValidSources(new List <string> { "dummy.te" })); }
public void PopulateSettingsShouldInitializeDefaultSettingsWhenRunSettingsIsNull() { MSTestSettings.PopulateSettings(this.mockDiscoveryContext.Object); MSTestSettings adapterSettings = MSTestSettings.CurrentSettings; Assert.IsTrue(adapterSettings.CaptureDebugTraces); Assert.IsFalse(adapterSettings.MapInconclusiveToFailed); Assert.IsTrue(adapterSettings.MapNotRunnableToFailed); Assert.IsTrue(adapterSettings.EnableBaseClassTestMethodsFromOtherAssemblies); }
public void GetFilterExpressionForValidRunContextReturnsValidTestCaseFilterExpression() { TestableTestExecutionRecorder recorder = new TestableTestExecutionRecorder(); var dummyFilterExpression = new TestableTestCaseFilterExpression(); TestableRunContext runContext = new TestableRunContext(() => dummyFilterExpression); bool filterHasError; var filterExpression = this.TestMethodFilter.GetFilterExpression(runContext, recorder, out filterHasError); Assert.AreEqual(dummyFilterExpression, filterExpression); Assert.IsFalse(filterHasError); }
public void GetResolutionPathsShouldAddTestPlatformFolderPath() { // Setup TestSourceHost sut = new TestSourceHost(null, null, null); // Execute List <string> result = sut.GetResolutionPaths("DummyAssembly.dll", isPortableMode: false); // Assert Assert.IsFalse(result.Contains(typeof(AssemblyHelper).Assembly.Location)); }
public void WhenDiscoveryOfInternalsIsEnabledIsValidTestMethodShouldReturnFalseForPrivateMethods() { this.SetupTestMethod(); var methodInfo = typeof(DummyTestClass).GetMethod( "PrivateTestMethod", BindingFlags.Instance | BindingFlags.NonPublic); var testMethodValidator = new TestMethodValidator(this.mockReflectHelper.Object, true); Assert.IsFalse(testMethodValidator.IsValidTestMethod(methodInfo, typeof(DummyTestClass), this.warnings)); }
public void DisableParallelizationShouldBeFalseByDefault() { string runSettingxml = @"<RunSettings> </RunSettings>"; this.mockDiscoveryContext.Setup(dc => dc.RunSettings).Returns(this.mockRunSettings.Object); this.mockRunSettings.Setup(rs => rs.SettingsXml).Returns(runSettingxml); MSTestSettings.PopulateSettings(this.mockDiscoveryContext.Object); Assert.IsFalse(MSTestSettings.CurrentSettings.DisableParallelization); }