public void Execute(IResultsWriter resultsWriter)
{
var result = CreateResult();
resultsWriter.Begin(result);
ChildInstructions.ForEach(instruction => instruction.Execute(resultsWriter));
resultsWriter.End(result);
}
//broken - this should get something instead of scenarios[] cuz scenarios test rawTests
public SuiteResult Test(Assemblies assemblies, Scenario[] scenarios, IResultsWriter resultsWriter)
{
var scenarioResults = new List<ScenarioResult>(scenarios.Length);
Array.ForEach(scenarios, scenario => scenarioResults.Add(scenario.Test(null, resultsWriter)));
return new SuiteResult(suiteName, scenarioResults);
}
public override void Execute(IResultsWriter resultsWriter)
{
CellResult cellResult = Evaluate();
resultsWriter.Begin(cellResult);
Parent.RowResult.Add(cellResult);
resultsWriter.End(cellResult);
}
public override void Execute(IResultsWriter resultsWriter)
{
int biggestRowCount = (isOutputTest) ? MostRowsDataOrActual() : dataRowCount;
for (int row = 0; row < biggestRowCount; row++)
{
Parent.AddRowResult(ExecuteRowInstructions(resultsWriter), resultsWriter);
}
}
public Consumer(IConsumerCollection collection, IFileWorker worker, IResultsWriter writer)
{
_collection = collection;
_worker = worker;
_writer = writer;
_ctSource = new CancellationTokenSource();
}
private RowResult ExecuteRowInstructions(IResultsWriter resultsWriter)
{
RowResult rowResult = new RowResult();
AddRowResult(rowResult, resultsWriter);
resultsWriter.Begin(rowResult);
ChildInstructions.ForEach(instruction => instruction.Execute(resultsWriter));
resultsWriter.End(rowResult);
return RowResult;
}
public Session(
ProjectConfiguration configuration, Assemblies assemblies,
TestReaders testReaders, IResultsWriter resultsWriter)
{
this.configuration = configuration;
this.assemblies = assemblies;
this.testReaders = testReaders;
this.resultsWriter = resultsWriter;
testRunner = new TestRunner(assemblies);
}
private ThreadRunner(string assemblyLocation, IEnumerable <Type> featureTypes,
ILogger logger, string outputPath,
IResultsWriter resultsWriter)
{
_assemblyLocation = assemblyLocation;
_featureTypes = featureTypes.ToList();
_logger = logger;
_outputPath = outputPath;
_resultsWriter = resultsWriter;
}
public ProcessRunner(
IResultsWriter resultsWriter,
IResultsParser resultsParser,
IProgressDisplay progressDisplayBuilder,
IResultsStatsWriter resultsStatsWriter)
{
_resultsWriter = resultsWriter;
_resultsParser = resultsParser;
_progressDisplayBuilder = progressDisplayBuilder;
_resultsStatsWriter = resultsStatsWriter;
}
public override void Execute(IResultsWriter resultsWriter)
{
IEnumerator enumerator = (IEnumerator) DataCache[DataType.Enumerator];
int actualRowCount = 0;
while (enumerator.MoveNext())
actualRowCount++;
DataCache[DataType.ActualRowCount] = actualRowCount;
// somebody else needs that enumerator
enumerator.Reset();
}
public ScenarioResult Test(RawTest[] rawTests, IResultsWriter resultsWriter)
{
var results = new ScenarioResult(name);
resultsWriter.Begin(results);
UserCache cache = new UserCache();
foreach (RawTest rawTest in rawTests)
{
var realTest = rawTest.CreateRealTest(assemblies, cache);
results.Add(realTest.Test(resultsWriter));
}
resultsWriter.End(results);
return results;
}
public override void Execute(IResultsWriter resultsWriter)
{
IEnumerable enumerableTarget = (IEnumerable)DataCache[DataType.Source];
DataCache[DataType.Enumerator] = enumerableTarget.GetEnumerator();
}
public override void Execute(IResultsWriter resultsWriter)
{
IEnumerator enumerator = (IEnumerator) DataCache[DataType.Enumerator];
DataCache[DataType.Enumerated] = enumerator.MoveNext() ? enumerator.Current : RealTest.MISSING_ROW;
}
public void AddRowResult(RowResult result, IResultsWriter resultsWriter)
{
RowResult = result;
}
public override void Execute(IResultsWriter resultsWriter)
{
DataCache[DataType.Source] = new[] { DataCache[DataType.Source] };
}
public void Add(IResultsWriter writer)
{
writers.Add(writer);
}
//broken - this should get something instead of scenarios[]
public void Test(string suiteName, Scenario[] scenarios, IResultsWriter resultsWriter)
{
var suite = new Suite(suiteName);
suite.Test(assemblies, scenarios, resultsWriter);
}
public abstract void Execute(IResultsWriter resultsWriter);
public override void Execute(IResultsWriter resultsWriter)
{
DataCache[DataType.Source] = UserCache[cacheKey];
}
public override void Execute(IResultsWriter resultsWriter)
{
DataCache[DataType.DataRow] = enumerator.MoveNext() ? enumerator.Current : RealTest.MISSING_ROW;
}
public void Test(string scenarioName, RawTest[] rawTests, IResultsWriter resultsWriter)
{
var scenario = new Scenario(scenarioName, assemblies);
scenario.Test(rawTests, resultsWriter);
}
public override void Execute(IResultsWriter resultsWriter)
{
object adapter = Assemblies.Instantiate(adapterType, DataCache[DataType.Source]);
DataCache[DataType.Source] = adapter;
}
public void AddRowResult(RowResult result, IResultsWriter resultsWriter)
{
resultsWriter.Begin(result);
testResults.Add(result);
resultsWriter.End(result);
}
public override void Execute(IResultsWriter resultsWriter)
{
DataCache[DataType.Source] = Assemblies.Instantiate(sourceType);
}
public SubwordsProcessor(IWordsLoader wordsLoader, IResultsWriter resultsWriter)
{
_wordsLoader = wordsLoader;
_resultsWriter = resultsWriter;
_finalList = new ConcurrentBag <string>();
}
public override void Execute(IResultsWriter resultsWriter)
{
DataCache[DataType.ActionParameter] = Assemblies.Instantiate(actionParameterType);
}
public TestResult Test(IResultsWriter resultsWriter)
{
Execute(resultsWriter);
return CreateResult();
}
