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 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(); } }
/// <summary> /// Creates a new TestPage visual that in turn will setup and begin a /// unit test run. /// </summary> /// <param name="settings">Test harness settings to be applied.</param> /// <returns>A new RootVisual.</returns> /// <remarks>Assumes the calling assembly is a test assembly.</remarks> public static UIElement CreateTestPage(UnitTestSettings settings) { UnitTestSystem system = new UnitTestSystem(); Type testPageType = Environment.OSVersion.Platform == PlatformID.WinCE ? typeof(MobileTestPage) : typeof(TestPage); Type testPageInterface = typeof(ITestPage); if (settings.TestPanelType != null && testPageInterface.IsAssignableFrom(settings.TestPanelType)) { testPageType = settings.TestPanelType; } object testPage; try { // Try creating with an instance of the test harness testPage = Activator.CreateInstance(testPageType, settings.TestHarness); } catch { // Fall back to a standard instance only testPage = Activator.CreateInstance(testPageType); } PrepareTestService(settings, () => system.Run(settings)); // NOTE: A silent failure would be if the testPanel is not a // UIElement, and it returns anyway. return testPage as UIElement; }
/// <summary>Constructor.</summary> public UnitTestMonitor(UnitTestSettings settings) { // Setup initial conditions. if (settings == null) throw new ArgumentNullException("settings"); harness = settings.TestHarness; // Wire up events. WireEvents(true); }
/// <summary> /// A partial method for PrepareDefaultLogManager. /// </summary> /// <param name="settings">The test harness settings.</param> public static void PrepareCustomLogProviders(UnitTestSettings settings) { // TODO: Consider what to do on this one... // Should probably update to use the newer log system with events, // and then after that figure out when it applies... perhaps only // when someone first requests to use it. ////if (HtmlPage.IsEnabled) ////{ ////settings.LogProviders.Add(new TextFailuresLogProvider()); ////} }
/// <summary>Looks for tags within the assembly, and applies them if necessary.</summary> /// <param name="settings">The test settings.</param> /// <param name="applicationArgs">The args passed to the 'Application_Startup' method of the Silverlight application.</param> /// <remarks>If the 'current' tag is present anywhere within the assembly, this is the only tag which is applied.</remarks> public static void AssignTags(UnitTestSettings settings, StartupEventArgs applicationArgs) { // Setup initial conditions. var callingAssembly = Assembly.GetCallingAssembly(); // Add the 'current' tag if one exists within the assembly. if (HasCurrentTag(callingAssembly)) { settings.TagExpression = TagCurrent; return; } }
private UnitTestSettings CreateUnitTestSettings() { var settings = new UnitTestSettings(); settings.TestHarness = new UnitTestHarness(); settings.LogProviders.Add(new DebugOutputProvider()); settings.LogProviders.Add(new VisualStudioLogProvider()); settings.StartRunImmediately = true; settings.ShowTagExpressionEditor = false; settings.TestAssemblies.Add(Assembly.GetExecutingAssembly()); settings.TagExpression = "Integration"; return settings; }
void MainPage_Loaded(object sender, RoutedEventArgs e) { UnitTestSettings settings = new UnitTestSettings(); settings.TestAssemblies.Add(this.GetType().Assembly); settings.TestService = new WindowsPhoneTestService(settings); UnitTestSystem.SetStandardLogProviders(settings); settings.TestHarness = new UnitTestHarness(); var testPage = UnitTestSystem.CreateTestPage() as IMobileTestPage; BackKeyPress += (x, xe) => xe.Cancel = testPage.NavigateBack(); (Application.Current.RootVisual as PhoneApplicationFrame).Content = testPage; }
private UnitTestSettings ConfigureSettings() { #if MSTest2009July || MSTest2009October || MSTest2009November var settings = UnitTestSystem.CreateDefaultSettings(); #else var settings = new UnitTestSettings(); settings.TestHarness = new UnitTestHarness(); DebugOutputProvider item = new DebugOutputProvider(); item.ShowAllFailures = true; settings.LogProviders.Add(item); try { VisualStudioLogProvider visualStudioLogProvider = new VisualStudioLogProvider(); settings.LogProviders.Add(visualStudioLogProvider); } catch { } // Don't enable a U.I. when not specifying the U.I. Mode. if (!_clientTestRunConfiguration.WindowGeometry.ShouldShowWindow) { var statLightTestPage = new StatLightTestPage(); settings.TestHarness.TestPage = statLightTestPage; settings.TestPanelType = typeof(StatLightTestPage); } settings.StartRunImmediately = true; settings.ShowTagExpressionEditor = false; settings.TestService = null; #endif // Below is the custom stuff... settings.TagExpression = _clientTestRunConfiguration.TagFilter; settings.LogProviders.Add(new ServerHandlingLogProvider()); foreach (var assembly in _loadedXapData.TestAssemblies) { settings.TestAssemblies.Add(assembly); } settings.TestHarness.TestHarnessCompleted += CurrentHarness_TestHarnessCompleted; return settings; }
/// <summary> /// Initializes the test service and its contained providers. /// </summary> /// <param name="inputSettings">The run settings.</param> /// <param name="complete">Action to call once the test service is /// initialized and ready to continue the run's execution.</param> private static void PrepareTestService(UnitTestSettings inputSettings, Action complete) { TestServiceProvider testService = inputSettings.TestService; if (testService != null && testService.Initialized == false) { Action after = delegate { MergeSettingsAndParameters(testService, inputSettings); complete(); }; testService.InitializeCompleted += delegate(object sender, EventArgs e) { after(); }; testService.Initialize(); } else { complete(); } }
public void Run(UnitTestSettings settings) { // Avoid having the Run method called twice if (_harness != null) { return; } // Track the most recent system in use _system = this; _harness = settings.TestHarness; if (_harness == null) { throw new InvalidOperationException(Properties.UnitTestMessage.UnitTestSystem_Run_NoTestHarnessInSettings); } _harness.Initialize(settings); _harness.TestHarnessCompleted += (sender, args) => OnTestHarnessCompleted(args); _harness.Run(); }
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); }
/// <summary> /// Merge any settings provided by a test service with the parameters /// that were passed inside the TestHarnessSettings. /// </summary> /// <param name="testService">The test service.</param> /// <param name="inputSettings">The run settings.</param> private static void MergeSettingsAndParameters(TestServiceProvider testService, UnitTestSettings inputSettings) { if (testService != null && testService.HasService(TestServiceFeature.RunSettings)) { SettingsProvider settings = testService.GetService<SettingsProvider>(TestServiceFeature.RunSettings); foreach (string key in settings.Settings.Keys) { if (inputSettings.Parameters.ContainsKey(key)) { Debug.WriteLine("MergeSettingsAndParameters: Overwriting " + key + " key during merge."); } inputSettings.Parameters[key] = settings.Settings[key]; } } }
/// <summary> /// Tries to instantiate and initialize a VSTT provider. Requires that /// XLinq is available and included in the application package. /// </summary> /// <param name="settings">The test harness settings object.</param> private static void TryAddVisualStudioLogProvider(UnitTestSettings settings) { VisualStudioLogProvider trx = new VisualStudioLogProvider(); settings.LogProviders.Add(trx); }
/// <summary> /// Creates a new TestPage visual that in turn will setup and begin a /// unit test run. /// </summary> /// <returns>A new RootVisual.</returns> /// <remarks>Assumes the calling assembly is a test assembly.</remarks> public static UIElement CreateTestPage() { UnitTestSettings settings = CreateDefaultSettings(Assembly.GetCallingAssembly()); return(CreateTestPage(settings)); }
/// <summary> /// A partial method for setting the TestService. /// </summary> /// <param name="settings">The test harness settings.</param> public static void SetTestService(UnitTestSettings settings) { settings.TestService = new WindowsPhoneTestService(settings); }
/// <summary> /// A partial method for setting the TestService. /// </summary> /// <param name="settings">The test harness settings.</param> public static void SetTestService(UnitTestSettings settings) { settings.TestService = new SilverlightTestService(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("NoTestHarnessInSettings"); } // Conside re-setting the test service only in our default case if (settings.TestService is SilverlightTestService) { SetTestService(settings); } _harness.Settings = settings; _harness.TestHarnessCompleted += (sender, args) => OnTestHarnessCompleted(args); if (settings.StartRunImmediately) { _harness.Run(); } }
public static UnitTestSettings CreateDefaultSettings(SilverlightUnitTestRunSettings silverlightUnitTestRunSettings) { var settings = new UnitTestSettings(); settings.ShowTagExpressionEditor = false; settings.SampleTags = new List<string>(); settings.TagExpression = null; if (silverlightUnitTestRunSettings != null) { if (silverlightUnitTestRunSettings.AssembliesThatContainTests.Any()) { foreach (var assemblyPartDllName in silverlightUnitTestRunSettings.AssembliesThatContainTests) { var partDllNameCopy = assemblyPartDllName; var foundAssemblyPart = Deployment.Current.Parts.FirstOrDefault(p => p.Source == partDllNameCopy); if (foundAssemblyPart != null) { var sri = Application.GetResourceStream(new Uri(foundAssemblyPart.Source, UriKind.Relative)); var assembly = new AssemblyPart().Load(sri.Stream); settings.TestAssemblies.Add(assembly); } } } if (!string.IsNullOrWhiteSpace(silverlightUnitTestRunSettings.TagFilter)) { settings.TagExpression = silverlightUnitTestRunSettings.TagFilter; } } SetStandardLogProviders(settings); settings.TestHarness = new LighthouseUnitTestHarness(); settings.TestHarness.Settings = settings; // Sets initial but user can override SetTestService(settings); return settings; }
/// <summary> /// Creates a new TestPage visual that in turn will setup and begin a /// unit test run. /// </summary> /// <param name="settings">Test harness settings to be applied.</param> /// <returns>A new RootVisual.</returns> /// <remarks>Assumes the calling assembly is a test assembly.</remarks> public static UIElement CreateTestPage(UnitTestSettings settings) { UnitTestSystem system = new UnitTestSystem(); PrepareTestService(settings, () => system.Run(settings)); return new TestPage(); }
protected override TestRunFilter CreateTestRunFilter(UnitTestSettings settings) { if(string.IsNullOrEmpty(settings.TagExpression)) return new AgTestRunFilter(settings, this); else return new TagTestRunFilter(settings, this, settings.TagExpression); }
private static void GetTestAssemblies(UnitTestSettings settings) { // Add more assemblies here that need to be unit tested. settings.TestAssemblies.Add(BibleLib.UnitTests.Properties.UnitTestAssembly.GetAssembly()); settings.TestAssemblies.Add(EverlastingBible.WP7.Specs.Properties.UnitTestAssembly.GetAssembly()); }
private static UnitTestSettings CreateDefaultSettings(IEnumerable<Assembly> callingAssemblies) { var settings = new UnitTestSettings(); settings.ShowTagExpressionEditor = false; settings.SampleTags = new List<string>(); settings.TagExpression = null; if (callingAssemblies != null) { foreach (var callingAssembly in callingAssemblies) { if (!settings.TestAssemblies.Contains(callingAssembly)) { settings.TestAssemblies.Add(callingAssembly); } } } SetStandardLogProviders(settings); settings.TestHarness = new LighthouseUnitTestHarness(); settings.TestHarness.Settings = settings; // Sets initial but user can override SetTestService(settings); return settings; }
public MethodNameTestRunFilter(UnitTestSettings settings, UnitTestHarness harness) : base(settings, harness) { }
public AgTestRunFilter(UnitTestSettings settings, UnitTestHarness harness) : base(settings, harness) { }
/// <summary> /// Merge any settings provided by a test service with the parameters /// that were passed inside the TestHarnessSettings. /// </summary> /// <param name="testService">The test service.</param> /// <param name="inputSettings">The run settings.</param> private static void MergeSettingsAndParameters(TestServiceProvider testService, UnitTestSettings inputSettings) { if (testService != null && testService.HasService(TestServiceFeature.RunSettings)) { SettingsProvider settings = testService.GetService <SettingsProvider>(TestServiceFeature.RunSettings); foreach (string key in settings.Settings.Keys) { if (inputSettings.Parameters.ContainsKey(key)) { Debug.WriteLine("MergeSettingsAndParameters: Overwriting " + key + " key during merge."); } inputSettings.Parameters[key] = settings.Settings[key]; } } }
public RiaTestRunFilter(UnitTestSettings settings, UnitTestHarness harness, Func<ITestMethod, bool> includeTest) : base(settings, harness) { _includeTest = includeTest; }
static UIElement CreateRootVisual(UnitTestSettings settings) { TestPage testPage = (TestPage)UnitTestSystem.CreateTestPage(settings); ComboBox comboBox = null; TestGrid grid = new TestGrid(comboBox, testPage); return grid; }
/// <summary> /// Prepares the default log manager. /// </summary> /// <param name="settings">The test harness settings.</param> public static void SetStandardLogProviders(UnitTestSettings settings) { // Debug provider DebugOutputProvider debugger = new DebugOutputProvider(); debugger.ShowAllFailures = true; settings.LogProviders.Add(debugger); // Visual Studio log provider try { TryAddVisualStudioLogProvider(settings); } catch { } PrepareCustomLogProviders(settings); }
/// <summary> /// Create a default settings object for unit testing. /// </summary> /// <param name="callingAssembly">The assembly reflection object.</param> /// <returns>A unit test settings instance.</returns> private static UnitTestSettings CreateDefaultSettings(Assembly callingAssembly) { UnitTestSettings settings = new UnitTestSettings(); if (callingAssembly != null) { settings.TestAssemblies.Add(callingAssembly); } SetStandardLogProviders(settings); settings.TestHarness = new UnitTestHarness(); // Not a default value for now SetTestService(settings); return settings; }
/// <summary> /// Create a default settings object for unit testing. /// </summary> /// <param name="callingAssembly">The assembly reflection object.</param> /// <returns>A unit test settings instance.</returns> private static UnitTestSettings CreateDefaultSettings(Assembly callingAssembly) { UnitTestSettings settings = new UnitTestSettings(); if (callingAssembly != null) { settings.TestAssemblies.Add(callingAssembly); } SetStandardLogProviders(settings); settings.TestHarness = new UnitTestHarness(); // Sets initial but user can override SetTestService(settings); return settings; }