/// <summary>
/// Initializes a new instance of the SilverlightTestService class.
/// </summary>
/// <param name="settings">Unit test settings to read the service path
/// and other information from.</param>
public SilverlightTestService(UnitTestSettings settings)
: this()
{
if (ServiceType == ServiceType.WebService)
{
SetServicePath(settings);
}
}
private UnitTestSettings ConfigureSettings()
{
#if July2009 || October2009 || November2009
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.ShowTestingBrowserHost)
{
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 a new instance of the App class.
/// </summary>
public App()
{
Startup += delegate
{
UnitTestSettings settings = UnitTestSystem.CreateDefaultSettings();
settings.SampleTags = new System.Collections.Generic.List <string>
{
"All",
"WrapPanelTest",
"WrapPanelTest-DP",
"WrapPanelTest+DockPanelTest",
"(WrapPanelTest+DockPanelTest)-DP",
"WrapPanelTest*DP",
"!DP",
};
RootVisual = UnitTestSystem.CreateTestPage(settings);
};
InitializeComponent();
}
/// <summary>
/// Run the unit tests.
/// </summary>
private void RunTests()
{
// Update the history
string tag = txtTag.Text;
TagHistory.Remove(tag);
TagHistory.Insert(0, tag);
while (TagHistory.Count > 5)
{
TagHistory.RemoveAt(5);
}
IsolatedStorageSettings.SiteSettings[TagHistoryKey] = TagHistory;
// Launch Ignite with the test tag
UnitTestSettings settings = UnitTestSystem.CreateDefaultSettings();
settings.TagExpression = tag;
Root.Children.Clear();
Root.Children.Add(UnitTestSystem.CreateTestPage(settings));
}
// Constructor
public MainPage()
{
InitializeComponent();
const bool runUnitTests = true;
if (runUnitTests)
{
UnitTestSettings settings = UnitTestSystem.CreateDefaultSettings();
#if AUTOUNITTEST
settings.StartRunImmediately = true;
settings.ShowTagExpressionEditor = false;
settings.TestHarness.TestHarnessCompleted += TestRunCompletedCallback;
#endif
Content = UnitTestSystem.CreateTestPage(settings);
}
// Sample code to localize the ApplicationBar
//BuildLocalizedApplicationBar();
}
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);
}
/// <summary>
/// Determine what test assemblies need to be executed. Enqueue tasks
/// for the unit test assembly providers to run the tests.
/// </summary>
private void PrepareTestAssemblyTasks()
{
// Regular unit test run
UnitTestSettings settings = Settings as UnitTestSettings;
TestRunFilter filter = CreateTestRunFilter(settings);
// Log the filter information
LogWriter.TestRunFilterSelected(filter);
// Add the test assemblies
foreach (Assembly assembly in Settings.TestAssemblies)
{
EnqueueTestAssembly(assembly, filter);
}
if (_validTestAssemblies > 0)
{
LogWriter.UnitTestHarnessStage(this, HarnessName, TestStage.Starting);
}
else
{
LogWriter.Warning(Properties.UnitTestMessage.UnitTestHarness_TestAssembliesNotActionable);
}
}
private string GetBaseTestModule(UnitTestSettings settings = null)
{
if (settings is null)
{
settings = _settings.Create();
}
string declaration;
string initialization;
var asserts = settings.AssertMode == AssertMode.PermissiveAssert ? PermissiveAssertClassName : AssertClassName;
switch (settings.BindingMode)
{
case BindingMode.EarlyBinding:
declaration = string.Format(EarlyBindingDeclarations, asserts);
initialization = string.Format(EarlyBindingInitialization, asserts);
break;
case BindingMode.LateBinding:
declaration = LateBindingDeclarations;
initialization = string.Format(LateBindingInitialization, asserts);
break;
case BindingMode.DualBinding:
declaration = string.Format(DualBindingDeclarations, asserts);
initialization = string.Format(DualBindingInitialization, asserts);
break;
default:
throw new ArgumentOutOfRangeException();
}
return(string.Format(TestModuleTemplate,
_isAccess ? AccessCompareOption : string.Empty,
declaration,
initialization));
}
private string GetTestModule(UnitTestSettings settings)
{
var assertClass = settings.AssertMode == AssertMode.StrictAssert ? string.Empty : "Permissive";
var moduleBinding = settings.BindingMode == BindingMode.EarlyBinding
? string.Format(ModuleEarlyBinding, assertClass)
: ModuleLateBinding;
var formattedModuleTemplate = string.Format(TestModuleEmptyTemplate, moduleBinding);
if (settings.ModuleInit)
{
var lateBindingString = string.Format(ModuleInitLateBinding,
settings.AssertMode == AssertMode.StrictAssert ? string.Empty : "Permissive");
formattedModuleTemplate += string.Format(_moduleInit, settings.BindingMode == BindingMode.EarlyBinding ? string.Empty : lateBindingString);
}
if (settings.MethodInit)
{
formattedModuleTemplate += _methodInit;
}
return(formattedModuleTemplate);
}
/// <summary>
/// Creates the test run filter for the initial run.
/// </summary>
/// <param name="settings">The unit test settings.</param>
/// <returns>Returns a new TestRunFilter instance.</returns>
protected virtual TestRunFilter CreateTestRunFilter(UnitTestSettings settings)
{
return String.IsNullOrEmpty(settings.TagExpression) ? new TestRunFilter(settings, this) : new TagTestRunFilter(settings, this, settings.TagExpression);
}
/// <summary>
/// Initializes a new instance of the TestRunStartingEventArgs
/// type.
/// </summary>
/// <param name="settings">The test run filter.</param>
/// <param name="filter">The test run settings object.</param>
public TestRunStartingEventArgs(UnitTestSettings settings, TestRunFilter filter)
: base()
{
Settings = settings;
TestRunFilter = filter;
}
/// <summary>
/// Initializes the test harness.
/// </summary>
/// <param name="settings">The test harness settings.</param>
public void Initialize(UnitTestSettings settings)
{
UnitTestHarness uth = settings.TestHarness as UnitTestHarness;
if (uth != null)
{
// Attach to store the log file
uth.Publishing += (o, e) => WriteLogFile(uth);
// Look for a unique test run ID
if (uth.TestService != null)
{
string runId = uth.TestService.UniqueTestRunIdentifier;
if (!string.IsNullOrEmpty(runId))
{
TestRunId = runId;
}
}
}
string filename;
if (settings.Parameters.TryGetValue("log", out filename))
{
TestResultsFileName = filename;
}
// Read pre-defined optional settings and environment variables
List <string> prefix = new List <string>();
string initialPrefix;
if (settings.Parameters.TryGetValue("testRunNamePrefix", out initialPrefix))
{
prefix.Add(initialPrefix);
}
string userName;
if (settings.Parameters.TryGetValue("userName", out userName))
{
prefix.Add(userName);
UserName = userName;
}
string computerName;
if (settings.Parameters.TryGetValue("computerName", out computerName))
{
prefix.Add(computerName);
ComputerName = computerName;
}
for (int i = 0; i < prefix.Count; ++i)
{
if (TestRunNamePrefix.Length > 0)
{
TestRunNamePrefix += "_";
}
TestRunNamePrefix += prefix[i];
}
}
/// <summary>
/// Initializes a new test run filter using an existing settings file.
/// </summary>
/// <param name="settings">A unit test settings instance.</param>
/// <param name="harness">The unit test harness.</param>
public TestRunFilter(UnitTestSettings settings, UnitTestHarness harness)
{
TestRunName = DefaultTestRunName;
_settings = settings;
UnitTestHarness = harness;
}
/// <summary>
/// Initializes a new test run filter with the tag expression.
/// </summary>
/// <param name="settings">Unit test settings.</param>
/// <param name="harness">Unit test harness.</param>
/// <param name="tagExpression">The tag expression to use.</param>
public TagTestRunFilter(UnitTestSettings settings, UnitTestHarness harness, string tagExpression)
: base(settings, harness)
{
SetTagExpression(tagExpression);
}
/// <summary>
/// Initializes the test harness.
/// </summary>
/// <param name="settings">The test harness settings.</param>
public void Initialize(UnitTestSettings settings)
{
UnitTestHarness uth = settings.TestHarness as UnitTestHarness;
if (uth != null)
{
// Attach to store the log file
uth.Publishing += (o, e) => WriteLogFile(uth);
// Look for a unique test run ID
if (uth.TestService != null)
{
string runId = uth.TestService.UniqueTestRunIdentifier;
if (!string.IsNullOrEmpty(runId))
{
TestRunId = runId;
}
}
}
string filename;
if (settings.Parameters.TryGetValue("log", out filename))
{
TestResultsFileName = filename;
}
// Read pre-defined optional settings and environment variables
List<string> prefix = new List<string>();
string initialPrefix;
if (settings.Parameters.TryGetValue("testRunNamePrefix", out initialPrefix))
{
prefix.Add(initialPrefix);
}
string userName;
if (settings.Parameters.TryGetValue("userName", out userName))
{
prefix.Add(userName);
UserName = userName;
}
string computerName;
if (settings.Parameters.TryGetValue("computerName", out computerName))
{
prefix.Add(computerName);
ComputerName = computerName;
}
for (int i = 0; i < prefix.Count; ++i)
{
if (TestRunNamePrefix.Length > 0)
{
TestRunNamePrefix += "_";
}
TestRunNamePrefix += prefix[i];
}
}
/// <summary>
/// Initializes a new instance of the SilverlightTestService class.
/// </summary>
/// <param name="settings">Unit test settings to read the service path
/// and other information from.</param>
public WindowsPhoneTestService(UnitTestSettings settings)
: this()
{
SetServicePath(settings);
}
/// <summary>
/// Creates the test run filter for the initial run.
/// </summary>
/// <param name="settings">The unit test settings.</param>
/// <returns>Returns a new TestRunFilter instance.</returns>
protected virtual TestRunFilter CreateTestRunFilter(UnitTestSettings settings)
{
TestRunFilter subfilter = String.IsNullOrEmpty(settings.TagExpression) ? new TestRunFilter(settings, this) : new TagTestRunFilter(settings, this, settings.TagExpression);
return(new RuntimeVersionTestRunFilter(settings, this, subfilter));
}
public RuntimeVersionTestRunFilter(UnitTestSettings settings, UnitTestHarness harness, TestRunFilter subfilter) : base(settings, harness)
{
this.subfilter = subfilter;
this.runtime_version = settings.RuntimeVersion;
}
/// <summary>
/// Initializes a new instance of the TestRunStartingEventArgs
/// type.
/// </summary>
/// <param name="settings">The test run filter.</param>
/// <param name="filter">The test run settings object.</param>
public TestRunStartingEventArgs(UnitTestSettings settings, TestRunFilter filter)
: base()
{
Settings = settings;
TestRunFilter = filter;
}
/// <summary>
/// Creates the test run filter for the initial run.
/// </summary>
/// <param name="settings">The unit test settings.</param>
/// <returns>Returns a new TestRunFilter instance.</returns>
protected virtual TestRunFilter CreateTestRunFilter(UnitTestSettings settings)
{
return(String.IsNullOrEmpty(settings.TagExpression) ? new TestRunFilter(settings, this) : new TagTestRunFilter(settings, this, settings.TagExpression));
}
private void Application_Startup(object sender, StartupEventArgs e)
{
UnitTestSettings s = UnitTestSystem.CreateDefaultSettings();
this.RootVisual = UnitTestSystem.CreateTestPage(s);
}
public RiaTestRunFilter(UnitTestSettings settings, UnitTestHarness harness, Func <ITestMethod, bool> includeTest)
: base(settings, harness)
{
_includeTest = includeTest;
}
/// <summary>
/// Creates the test run filter for the initial run.
/// </summary>
/// <param name="settings">The unit test settings.</param>
/// <returns>Returns a new TestRunFilter instance.</returns>
protected virtual TestRunFilter CreateTestRunFilter(UnitTestSettings settings)
{
TestRunFilter subfilter = String.IsNullOrEmpty(settings.TagExpression) ? new TestRunFilter(settings, this) : new TagTestRunFilter(settings, this, settings.TagExpression);
return new RuntimeVersionTestRunFilter (settings, this, subfilter);
}
/// <summary>
/// Initializes a new test run filter with the tag expression.
/// </summary>
/// <param name="settings">Unit test settings.</param>
/// <param name="harness">Unit test harness.</param>
/// <param name="tagExpression">The tag expression to use.</param>
public TagTestRunFilter(UnitTestSettings settings, UnitTestHarness harness, string tagExpression)
: base(settings, harness)
{
SetTagExpression(tagExpression);
}
/// <summary>
/// Initializes a new test run filter using an existing settings file.
/// </summary>
/// <param name="settings">A unit test settings instance.</param>
/// <param name="harness">The unit test harness.</param>
public TestRunFilter(UnitTestSettings settings, UnitTestHarness harness)
{
TestRunName = DefaultTestRunName;
_settings = settings;
UnitTestHarness = harness;
}
public RuntimeVersionTestRunFilter(UnitTestSettings settings, UnitTestHarness harness, TestRunFilter subfilter) : base(settings, harness)
{
this.subfilter = subfilter;
this.runtime_version = settings.RuntimeVersion;
}
/// <summary>
/// Determine the service path to attempt to use, and prepares the
/// verification object using those parameters.
/// </summary>
/// <param name="settings">Unit test settings object to try and read
/// settings from.</param>
private void SetServicePath(UnitTestSettings settings)
{
bool useOverrides = (settings != null && !string.IsNullOrEmpty(settings.TestServiceHostname) && !string.IsNullOrEmpty(settings.TestServicePath));
_webService = new ServiceVerifier
{
Hostname = useOverrides ? settings.TestServiceHostname : "localhost",
Port = useOverrides ? settings.TestServicePort : 8000,
ServicePath = useOverrides ? settings.TestServicePath : "/externalInterface/",
};
}
/// <summary>
/// Initializes a new instance of the SilverlightTestService class.
/// </summary>
/// <param name="settings">Unit test settings to read the service path
/// and other information from.</param>
public WindowsPhoneTestService(UnitTestSettings settings)
: this()
{
SetServicePath(settings);
}
/// <summary>
/// Fill member variables with any non-null settings of the same type.
/// </summary>
/// <param name="settings">Settings container class.</param>
private void InitializeSettings(UnitTestSettings settings)
{
if (settings != null)
{
if (settings.LogProviders != null)
{
LogProviders = settings.LogProviders;
}
if (settings.Parameters != null)
{
Parameters = settings.Parameters;
}
Settings = settings;
}
}
public AgTestRunFilter(UnitTestSettings settings, UnitTestHarness harness) : base(settings, harness)
{
}
