/// <summary>
/// Gets the included test items for the given module and suite
/// </summary>
/// <param name="module">The test module data</param>
/// <param name="suite">The test suite</param>
/// <param name="logWriter">optional log writer in case something goes wrong</param>
/// <returns>The included test items without the excluded items</returns>
public static IEnumerable<TestItemData> GetIncludedVariations(TestModuleData module, TestSuite suite, ITestLogWriter logWriter)
{
ExceptionUtilities.CheckArgumentNotNull(suite, "suite");
var included = suite.Items.Where(i => i.IsIncluded).Select(i => i.Name);
var excluded = suite.Items.Where(i => !i.IsIncluded).Select(i => i.Name);
return GetIncludedVariations(module, included, excluded, logWriter);
}
/// <summary>
/// Safely disposes the test log writer
/// </summary>
/// <param name="testLogWriter">The test log writer to dispose</param>
public void Terminate(ITestLogWriter testLogWriter)
{
List<TextWriter> textWriters = this.compositeToTextWritersLookup[testLogWriter as CompositeTestLogWriter];
foreach (TextWriter writer in textWriters)
{
writer.Dispose();
}
}
/// <summary>
/// Safely disposes the test log writer
/// </summary>
/// <param name="testLogWriter">The test log writer to dispose</param>
public void Terminate(ITestLogWriter testLogWriter)
{
List <TextWriter> textWriters = this.compositeToTextWritersLookup[testLogWriter as CompositeTestLogWriter];
foreach (TextWriter writer in textWriters)
{
writer.Dispose();
}
}
/// <summary>
/// Runs the specified module.
/// </summary>
/// <param name="testModuleData">Data about the test module to run.</param>
/// <param name="logWriter">The log writer.</param>
/// <param name="variationsToRun">The variations to run.</param>
/// <param name="parameters">The parameters.</param>
public void Run(TestModuleData testModuleData, ITestLogWriter logWriter, IEnumerable <TestItemData> variationsToRun, IDictionary <string, string> parameters)
{
ExceptionUtilities.CheckArgumentNotNull(testModuleData, "testModuleData");
ExceptionUtilities.CheckArgumentNotNull(logWriter, "logWriter");
if (parameters == null)
{
parameters = new Dictionary <string, string>();
}
var testModule = (TestModule)Activator.CreateInstance(testModuleData.TestItemType);
testModule.ExplorationSeed = testModuleData.ExplorationSeed;
testModule.ExplorationKind = testModuleData.ExplorationKind;
foreach (var param in parameters)
{
testModule.TestParameters[param.Key] = param.Value;
}
if (variationsToRun == null)
{
variationsToRun = testModuleData.GetAllChildrenRecursive().Where(c => c.IsVariation);
}
lock (this.lockObject)
{
var logger = new TestLogWriterLogger(logWriter);
logger.OnWarning += this.OnWarning;
testModule.Log = logger;
this.executionThreadAborted = false;
this.runCompleted = false;
this.currentLogWriter = logWriter;
this.scheduledVariations = variationsToRun.Distinct().ToDictionary <TestItemData, TestItemData>(iteration => iteration);
this.completedItems.Clear();
this.statisticsByPriority.Clear();
this.globalStatistics = new RunStatistics();
this.currentLogWriter.BeginTestSuite();
this.executionThread = new Thread(this.ExecutionThreadStart)
{
IsBackground = true,
};
this.executionThread.Start();
this.BeginExecution(testModule, testModuleData);
}
}
/// <summary>
/// Gets the included variations for the given module
/// </summary>
/// <param name="module">The test module data</param>
/// <param name="includedPaths">The included paths</param>
/// <param name="excludedPaths">The excluded paths</param>
/// <param name="logWriter">optional log writer in case something goes wrong</param>
/// <returns>The included test items without the excluded items</returns>
internal static IEnumerable<TestItemData> GetIncludedVariations(TestModuleData module, IEnumerable<string> includedPaths, IEnumerable<string> excludedPaths, ITestLogWriter logWriter)
{
ExceptionUtilities.CheckArgumentNotNull(module, "module");
ExceptionUtilities.CheckArgumentNotNull(includedPaths, "includedPaths");
ExceptionUtilities.CheckArgumentNotNull(excludedPaths, "excludedPaths");
var allPossibleItems = module.GetAllChildrenRecursive().Where(i => i.IsVariation).ToList();
var includedItems = new List<TestItemData>();
bool anyIncludedPath = false;
foreach (var includedPath in includedPaths)
{
anyIncludedPath = true;
var toAdd = FilterItemsByPath(allPossibleItems, includedPath).ToList();
if (toAdd.Count > 0)
{
includedItems.AddRange(toAdd);
// TODO: should we remove them?
// It seems like it would make subsequent lookups faster and avoid the possibility of double-including something
toAdd.ForEach(i => allPossibleItems.Remove(i));
}
else if (logWriter != null)
{
var safeString = includedPath.Replace('/', '\\');
logWriter.WriteLine(LogLevel.Warning, string.Format(CultureInfo.InvariantCulture, "No test items found for path '{0}' in module '{1}'", safeString, module.Metadata.Name));
}
}
// special case, if no includes are specified, just take everything
if (!anyIncludedPath)
{
includedItems = allPossibleItems;
}
foreach (var excludedPath in excludedPaths)
{
var toRemove = FilterItemsByPath(includedItems, excludedPath).ToList();
toRemove.ForEach(i => includedItems.Remove(i));
}
return includedItems;
}
/// <summary>
/// Gets the included variations for the given module
/// </summary>
/// <param name="module">The test module data</param>
/// <param name="includedPaths">The included paths</param>
/// <param name="excludedPaths">The excluded paths</param>
/// <param name="logWriter">optional log writer in case something goes wrong</param>
/// <returns>The included test items without the excluded items</returns>
internal static IEnumerable <TestItemData> GetIncludedVariations(TestModuleData module, IEnumerable <string> includedPaths, IEnumerable <string> excludedPaths, ITestLogWriter logWriter)
{
ExceptionUtilities.CheckArgumentNotNull(module, "module");
ExceptionUtilities.CheckArgumentNotNull(includedPaths, "includedPaths");
ExceptionUtilities.CheckArgumentNotNull(excludedPaths, "excludedPaths");
var allPossibleItems = module.GetAllChildrenRecursive().Where(i => i.IsVariation).ToList();
var includedItems = new List <TestItemData>();
bool anyIncludedPath = false;
foreach (var includedPath in includedPaths)
{
anyIncludedPath = true;
var toAdd = FilterItemsByPath(allPossibleItems, includedPath).ToList();
if (toAdd.Count > 0)
{
includedItems.AddRange(toAdd);
// TODO: should we remove them?
// It seems like it would make subsequent lookups faster and avoid the possibility of double-including something
toAdd.ForEach(i => allPossibleItems.Remove(i));
}
else if (logWriter != null)
{
var safeString = includedPath.Replace('/', '\\');
logWriter.WriteLine(LogLevel.Warning, string.Format(CultureInfo.InvariantCulture, "No test items found for path '{0}' in module '{1}'", safeString, module.Metadata.Name));
}
}
// special case, if no includes are specified, just take everything
if (!anyIncludedPath)
{
includedItems = allPossibleItems;
}
foreach (var excludedPath in excludedPaths)
{
var toRemove = FilterItemsByPath(includedItems, excludedPath).ToList();
toRemove.ForEach(i => includedItems.Remove(i));
}
return(includedItems);
}
/// <summary>
/// Gets the included test items for the given module and suite
/// </summary>
/// <param name="module">The test module data</param>
/// <param name="suite">The test suite</param>
/// <param name="logWriter">optional log writer in case something goes wrong</param>
/// <returns>The included test items without the excluded items</returns>
public static IEnumerable <TestItemData> GetIncludedVariations(TestModuleData module, TestSuite suite, ITestLogWriter logWriter)
{
ExceptionUtilities.CheckArgumentNotNull(suite, "suite");
var included = suite.Items.Where(i => i.IsIncluded).Select(i => i.Name);
var excluded = suite.Items.Where(i => !i.IsIncluded).Select(i => i.Name);
return(GetIncludedVariations(module, included, excluded, logWriter));
}
/// <summary>
/// Runs the specified module.
/// </summary>
/// <param name="testModuleData">Data about the test module to run.</param>
/// <param name="logWriter">The log writer.</param>
/// <param name="variationsToRun">The variations to run.</param>
/// <param name="parameters">The test parameters with which to invoke the test module.</param>
public void Run(TestModuleData testModuleData, ITestLogWriter logWriter, IEnumerable <TestItemData> variationsToRun, IDictionary <string, string> parameters)
{
this.Runner.Run(testModuleData, logWriter, variationsToRun, parameters);
}
/// <summary>
/// Initializes a new instance of the TestLogWriterLogger class.
/// </summary>
/// <param name="writer">The writer to forward log messages to.</param>
public TestLogWriterLogger(ITestLogWriter writer)
{
this.writer = writer;
}
/// <summary>
/// Runs the specified module.
/// </summary>
/// <param name="testModuleData">Data about the test module to run.</param>
/// <param name="logWriter">The log writer.</param>
/// <param name="variationsToRun">The variations to run.</param>
/// <param name="parameters">The test parameters with which to invoke the test module.</param>
public void Run(TestModuleData testModuleData, ITestLogWriter logWriter, IEnumerable<TestItemData> variationsToRun, IDictionary<string, string> parameters)
{
this.Runner.Run(testModuleData, logWriter, variationsToRun, parameters);
}
