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();
}
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>
/// 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();
}
}
/// <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)
{
}
/// <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);
}
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;
}
/// <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);
}
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;
}
/// <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);
}
