/// <summary> /// Constructor for a test method manager, which handles executing a single test method /// for a unit test provider. /// </summary> /// <param name="testHarness">The unit test harness object.</param> /// <param name="testClass">The test class metadata object.</param> /// <param name="testMethod">The test method metadata object.</param> /// <param name="instance">The test class instance.</param> /// <param name="provider">The unit test provider.</param> public TestMethodManager(UnitTestHarness testHarness, ITestClass testClass, ITestMethod testMethod, object instance, IUnitTestProvider provider) : base(testHarness, provider) { _testClass = testClass; _testMethod = testMethod; _instance = instance; }
/// <summary> /// Initializes dispatcher-stack attaching method container work item. /// </summary> /// <param name="testHarness">Test harness.</param> /// <param name="instance">Test instance.</param> /// <param name="method">Method reflection object.</param> /// <param name="testMethod">Test method metadata.</param> /// <param name="granularity">Granularity of test.</param> public UnitTestMethodContainer(ITestHarness testHarness, object instance, MethodInfo method, ITestMethod testMethod, TestGranularity granularity) : base(instance, method, testMethod) { _granularity = granularity; _harness = testHarness as UnitTestHarness; _testMethod = testMethod; }
/// <summary> /// Create a new assembly manager, takes in the harness, provider /// reference and actual IAssembly object. /// </summary> /// <param name="runFilter">The test run filter object.</param> /// <param name="testHarness">Harness object.</param> /// <param name="provider">The unit test metadata provider.</param> /// <param name="testAssembly">The test assembly metadata object.</param> public AssemblyManager(TestRunFilter runFilter, UnitTestHarness testHarness, IUnitTestProvider provider, IAssembly testAssembly) : base(testHarness, provider) { _filter = runFilter; _assembly = testAssembly; _testClasses = new CompositeWorkItem(); ClassInstances = new TestClassInstanceDictionary(); }
/// <summary> /// A container type that handles an entire test class throughout the /// test run. /// </summary> /// <param name="filter">Test run filter object.</param> /// <param name="testHarness">The unit test harness.</param> /// <param name="testClass">The test class metadata interface.</param> /// <param name="instance">The object instance.</param> /// <param name="provider">The unit test provider.</param> public TestClassManager(TestRunFilter filter, UnitTestHarness testHarness, ITestClass testClass, object instance, IUnitTestProvider provider) : base(testHarness, provider) { _filter = filter; _testClass = testClass; _testExecutionQueue = new CompositeWorkItem(); _instance = instance; }
private void Application_Startup(object sender, StartupEventArgs e) { var harness = new UnitTestHarness(); var settings = new UnitTestSettings(); settings.TestHarness = harness; harness.Settings = settings; harness.Initialize(); harness.TestRunStarting += (senderx, ex) => { var provider = new TestProvider(); var filter = new TagTestRunFilter(settings, harness, settings.TagExpression); var features = FeatureFactory.GetFeatures(typeof(App).Assembly); foreach (var feature in features) { provider.RegisterFeature(feature); var ass = provider.GetUnitTestAssembly(harness, feature.Assembly); harness.EnqueueTestAssembly(ass, filter); } }; this.RootVisual = UnitTestSystem.CreateTestPage(settings); }
public static void RunTests(Application app) { UnitTestSettings settings = UnitTestSystem.CreateDefaultSettings(); settings.StartRunImmediately = SuppressTagExpressionEditor(); settings.ShowTagExpressionEditor = !SuppressTagExpressionEditor(); settings.TestHarness = new AgTestHarness(); TestHarness = (UnitTestHarness)settings.TestHarness; settings.TestAssemblies.Clear(); settings.TestAssemblies.Add(Assembly.GetCallingAssembly()); if (IsGUI()) { string categories = (string)HtmlPage.Window.Eval("window.external.GetIgnoreCategories();"); IgnoredCategories.AddRange(categories.Split(';')); settings.LogProviders.Clear(); settings.LogProviders.Add(new SilverlightTestGUILog()); TestHarness.TestHarnessCompleted += TestHarnessCompleted; } else { IgnoredCategories.Add("TODO"); } UnitTestProviders.Providers.Add(new BaseUnitTestProvider()); app.RootVisual = CreateRootVisual(settings); }
public void Run(UnitTestSettings settings) { // Avoid having the Run method called twice if (_harness != null) { return; } _harness = settings.TestHarness; if (_harness == null) { throw new InvalidOperationException(Properties.UnitTestMessage.UnitTestSystem_Run_NoTestHarnessInSettings); } if (settings.TestService == null && !settings.TestServiceSetterCalled) { SetTestService(settings); } _harness.Settings = settings; _harness.TestHarnessCompleted += (sender, args) => OnTestHarnessCompleted(args); if (settings.StartRunImmediately) { _harness.Run(); } }
public static UIElement CreateTestPage (Application app) { settings = new UnitTestSettings (); app.UnhandledException += Application_UnhandledException; moonlog = new MoonLogProvider (); harness = new Microsoft.Silverlight.Testing.UnitTesting.Harness.UnitTestHarness (); settings.TestHarness = harness; settings.TestAssemblies.Add (app.GetType ().Assembly); UnitTestSystem.PrepareCustomLogProviders (settings); settings.LogProviders.Add (moonlog); settings.RuntimeVersion = Int32.Parse (Deployment.Current.RuntimeVersion.Split('.')[0]); // Silverlight thinks HtmlPage.Document.DocumentUri.Query is empty // so lets just manually parse instead. This allows tagging to work on SL. if (HtmlPage.Document.DocumentUri.OriginalString.IndexOf ('?') > 0) { settings.TagExpression = HtmlPage.Document.DocumentUri.OriginalString.Substring (HtmlPage.Document.DocumentUri.OriginalString.IndexOf ('?') + 1); if (settings.TagExpression.IndexOf ('#') > 0) settings.TagExpression = settings.TagExpression.Remove (settings.TagExpression.IndexOf ('#')); } test_page = UnitTestSystem.CreateTestPage (settings); settings.TestHarness.TestHarnessCompleted += new EventHandler<TestHarnessCompletedEventArgs> (Harness_Completed); return test_page; }
public IAssembly GetUnitTestAssembly(UnitTestHarness testHarness, Assembly assemblyReference) { if (!this._assemblyCache.ContainsKey(assemblyReference)) { this._assemblyCache[assemblyReference] = new BaseTestAssembly(this, testHarness, assemblyReference); } return(this._assemblyCache[assemblyReference]); }
/// <summary> /// Creates a new unit test assembly wrapper. /// </summary> /// <param name="provider">Unit test metadata provider.</param> /// <param name="unitTestHarness">A reference to the unit test harness.</param> /// <param name="assembly">Assembly reflection object.</param> public UnitTestFrameworkAssembly(IUnitTestProvider provider, UnitTestHarness unitTestHarness, Assembly assembly) { _provider = provider; _harness = unitTestHarness; _assembly = assembly; _init = new LazyAssemblyMethodInfo(_assembly, ProviderAttributes.AssemblyInitialize); _cleanup = new LazyAssemblyMethodInfo(_assembly, ProviderAttributes.AssemblyCleanup); }
public BaseTestAssembly(IUnitTestProvider provider, UnitTestHarness testHarness, Assembly assembly) { this.provider = provider; this.testHarness = testHarness; this.assembly = assembly; this.init = new LazyAssemblyMethodInfo(this.assembly, typeof(AssemblyInitializeAttribute)); this.cleanup = new LazyAssemblyMethodInfo(this.assembly, typeof(AssemblyCleanupAttribute)); }
public UnitTestFrameworkAssembly(IUnitTestProvider provider, UnitTestHarness unitTestHarness, Assembly assembly) { this.provider = provider; harness = unitTestHarness; this.assembly = assembly; lazyMethodInfo = new LazyAssemblyMethodInfo(this.assembly, ProviderAttributes.AssemblyInitialize); cleanup = new LazyAssemblyMethodInfo(this.assembly, ProviderAttributes.AssemblyCleanup); }
/// <summary> /// Initializes a new instance of the DataManager type. /// </summary> /// <param name="harness">The unit test harness instance.</param> private DataManager(UnitTestHarness harness) { _d = new TestRunData(harness); _h = harness; _assemblyData = new Dictionary <IAssembly, TestAssemblyData>(2); _classData = new Dictionary <ITestClass, TestClassData>(50); _methodData = new Dictionary <ITestMethod, TestMethodData>(300); }
public IAssembly GetUnitTestAssembly(UnitTestHarness testHarness, Assembly assemblyReference) { if (assemblyCache.ContainsKey(assemblyReference)) { return(assemblyCache[assemblyReference]); } assemblyCache[assemblyReference] = new UnitTestFrameworkAssembly(this, testHarness, assemblyReference); return(assemblyCache[assemblyReference]); }
public TestAssembly( IUnitTestProvider provider, UnitTestHarness testHarness, Feature feature) { _provider = provider; _testHarness = testHarness; _feature = feature; _classes = new List <ITestClass>(); _classes.Add(new TestClass(this, _feature)); }
/// <summary> /// Initializes a new instance of the test run results. /// </summary> /// <param name="unitTestHarness">The unit test harness.</param> public TestRunData(UnitTestHarness unitTestHarness) { Passed = true; _assemblies = new ObservableCollection <TestAssemblyData>(); _harness = unitTestHarness; _harness.TestAssemblyStarting += (x, xe) => IsRunning = true; _harness.TestAssemblyCompleted += (x, xe) => { IsRunning = false; NotifyPropertyChanged("PassedAndComplete"); }; _harness.IsDispatcherRunningChanged += (x, xe) => NotifyPropertyChanged("IsDispatcherRunning"); }
void TestRunCompletedCallback(object sender, TestHarnessCompletedEventArgs e) { int testsPassed = 0; int testsFailed = 0; int testsInconclusive = 0; UnitTestHarness testHarness = sender as UnitTestHarness; using (IsolatedStorageFile isoStore = IsolatedStorageFile.GetUserStoreForApplication()) { using (IsolatedStorageFileStream stream = isoStore.OpenFile("pubnublog.txt", FileMode.OpenOrCreate)) { using (StreamWriter writer = new StreamWriter(stream)) { foreach (ScenarioResult result in testHarness.Results) { writer.WriteLine(result.ToString()); System.Diagnostics.Debug.WriteLine(result.ToString()); switch (result.Result) { case TestOutcome.Passed: case TestOutcome.Completed: testsPassed++; break; case TestOutcome.Inconclusive: testsInconclusive++; break; default: testsFailed++; // must be a failure of some kind // perform some outputting break; } } writer.WriteLine("Total Tests = " + testHarness.Results.Count); writer.WriteLine("Tests Passed = " + testsPassed); writer.WriteLine("Tests Failed = " + testsFailed); writer.WriteLine("Tests Inconclusive = " + testsInconclusive); System.Diagnostics.Debug.WriteLine("Total Tests = " + testHarness.Results.Count); System.Diagnostics.Debug.WriteLine("Tests Passed = " + testsPassed); System.Diagnostics.Debug.WriteLine("Tests Failed = " + testsFailed); System.Diagnostics.Debug.WriteLine("Tests Inconclusive = " + testsInconclusive); writer.Close(); } stream.Close(); } } }
/// <summary> /// Unit test harness starting message. /// </summary> /// <param name="l">Log message object.</param> private void UnitTestHarnessStart(LogMessage l) { _unitTestHarness = (UnitTestHarness)l[UnitTestLogDecorator.UnitTestHarness]; string displayName = "Unit Test Run for "; HtmlContainerControl harness = new HtmlDiv(); harness.InnerHtml = displayName; harness.Padding.All = 3; harness.BackgroundColor = Color.DarkGray; harness.ForegroundColor = Color.VeryLightGray; _mostRecentHarness = new HtmlSpan(); _mostRecentHarness.ForegroundColor = Color.White; harness.Controls.Add(_mostRecentHarness); LogContainer.Controls.Add(harness); }
/// <summary> /// Adds the retry action link. /// </summary> /// <param name="actions">The action container.</param> private void AddRetryAction(HtmlControl actions) { HtmlAnchor rerun = new HtmlAnchor( "Retry this test", delegate(object sender, HtmlEventArgs args) { RetryTestRunFilter retryFilter = new RetryTestRunFilter(Inspector.Result.TestClass, Inspector.Result.TestMethod); UnitTestHarness ut = UnitTestHarness; if (ut != null) { ut.RestartRunDispatcher(); ut.EnqueueTestAssembly(Inspector.Result.TestClass.Assembly, retryFilter); } }); StyleActionLink(rerun); actions.Controls.Add(rerun); }
public static UIElement CreateTestPage(Application app) { settings = new UnitTestSettings(); app.UnhandledException += Application_UnhandledException; moonlog = new MoonLogProvider(); harness = new Microsoft.Silverlight.Testing.UnitTesting.Harness.UnitTestHarness(); settings.TestHarness = harness; settings.TestAssemblies.Add(app.GetType().Assembly); UnitTestSystem.PrepareCustomLogProviders(settings); settings.LogProviders.Add(moonlog); settings.RuntimeVersion = Int32.Parse(Deployment.Current.RuntimeVersion.Split('.')[0]); // Silverlight thinks HtmlPage.Document.DocumentUri.Query is empty // so lets just manually parse instead. This allows tagging to work on SL. if (HtmlPage.Document.DocumentUri.OriginalString.IndexOf('?') > 0) { settings.TagExpression = HtmlPage.Document.DocumentUri.OriginalString.Substring(HtmlPage.Document.DocumentUri.OriginalString.IndexOf('?') + 1); if (settings.TagExpression.IndexOf('#') > 0) { settings.TagExpression = settings.TagExpression.Remove(settings.TagExpression.IndexOf('#')); } List <string> exps = new List <string> (settings.TagExpression.Split('&')); for (int i = exps.Count - 1; i >= 0; i--) { if (exps [i].StartsWith("version=") || exps [i].StartsWith("bot_mode=")) { exps.RemoveAt(i); } } settings.TagExpression = string.Join("&", exps.ToArray()); } test_page = UnitTestSystem.CreateTestPage(settings); settings.TestHarness.TestHarnessCompleted += new EventHandler <TestHarnessCompletedEventArgs> (Harness_Completed); return(test_page); }
public IAssembly GetUnitTestAssembly(UnitTestHarness testHarness, Assembly assemblyReference) { return(new TestAssembly(testHarness, assemblyReference, this)); }
public void WriteLogFile(UnitTestHarness harness) { _writer.Finished = DateTime.Now; harness.WriteLogFile(TestResultsFileName, _writer.GetXmlAsString()); }
/// <summary> /// Creates a new unit test assembly wrapper. /// </summary> /// <param name="provider">Unit test metadata provider.</param> /// <param name="unitTestHarness">A reference to the unit test harness.</param> /// <param name="assembly">Assembly reflection object.</param> public UnitTestFrameworkAssembly(IUnitTestProvider provider, UnitTestHarness unitTestHarness, Assembly assembly) { _provider = provider; _harness = unitTestHarness; _assembly = assembly; }
/// <summary> /// Initializes the TestPage object. /// </summary> /// <param name="harness">The test harness instance.</param> public TestPage(UnitTestHarness harness) : this() { harness.TestPage = this; _harness = harness; }
public AgTestRunFilter(UnitTestSettings settings, UnitTestHarness harness) : base(settings, harness) { }
public RuntimeVersionTestRunFilter(UnitTestSettings settings, UnitTestHarness harness, TestRunFilter subfilter) : base(settings, harness) { this.subfilter = subfilter; this.runtime_version = settings.RuntimeVersion; }
public RiaTestRunFilter(UnitTestSettings settings, UnitTestHarness harness, Func <ITestMethod, bool> includeTest) : base(settings, harness) { _includeTest = includeTest; }
/// <summary> /// Records a harness state for the unit test harness. /// </summary> /// <param name="harness">The unit test harness.</param> /// <param name="name">The harness name.</param> /// <param name="stage">The test stage.</param> public void UnitTestHarnessStage(UnitTestHarness harness, string name, TestStage stage) { LogMessage m = Create(LogMessageType.TestExecution, name); MarkUnitTestMessage(m); DecorateNameProperty(m, name); DecorateTestGranularity(m, TestGranularity.Harness); m[UnitTestLogDecorator.UnitTestHarness] = harness; DecorateTestStage(m, stage); Enqueue(m); }
public TestAssembly(UnitTestHarness testHarness, Assembly assembly, IUnitTestProvider provider) { this.testHarness = testHarness; this.assembly = assembly; this.provider = provider; }
/// <summary> /// Initializes a new instance of the DataManager. /// </summary> /// <param name="harness">The unit test harness instance.</param> /// <returns>Returns a new instance of a DataManager class.</returns> public static DataManager Create(UnitTestHarness harness) { return(new DataManager(harness)); }