public StepResult NextStep()
{
if (initBefore && lastStepResult == StepResult.NextRound)
{
InitRound();
}
if (round >= rounds)
{
return StepResult.Finished;
}
PerformInstruction();
lastStepResult = StepResult.Continue;
if (LiveWarriorsCount == 1 && WarriorsCount > 1)
{
liveWarriors.Peek().Result = RoundResult.Win;
lastStepResult = StepResult.NextRound;
NextRound();
}
else if (LiveWarriorsCount == 0 || cyclesLeft == 0)
{
lastStepResult = StepResult.NextRound;
NextRound();
}
return lastStepResult;
}
public void HasFailedSteps_should_return_false_if_no_failed_steps()
{
var passed = new StepResult("Foo".AsStringStep(""), new Passed());
_results.AddActionStepResult(passed);
var pending = new StepResult("Bar".AsStringStep(""), new Pending("yadda"));
_results.AddActionStepResult(pending);
Assert.IsFalse(_results.HasFailedSteps());
}
public void HasFailedSteps_should_report_failed_if_at_least_one_step_failed()
{
var passed = new StepResult("Foo".AsStringStep(""), new Passed());
_results.AddActionStepResult(passed);
var failed = new StepResult("Foo".AsStringStep(""), new Failed(new Exception()));
_results.AddActionStepResult(failed);
Assert.IsTrue(_results.HasFailedSteps());
}
protected override void EstablishContext()
{
var memStream = new MemoryStream();
var xmlWriter = new XmlTextWriter(memStream, Encoding.UTF8);
_xmlOutputWriter = new XmlOutputWriter(xmlWriter, new List<EventReceived>());
var result = new StepResult(Step("Given Foo"), Passed);
_xmlOutputWriter.DoStringStep(result);
xmlWriter.Flush();
_xmlDoc = new XmlDocument();
memStream.Seek(0, SeekOrigin.Begin);
_xmlDoc.Load(memStream);
}
public void BeginMatch(IProject project)
{
if (project.EngineOptions.EngineMode != EngineMode.Match)
throw new InvalidOperationException("This engine mode is supported only by method run");
InitializeMatch(project);
InitializeRound();
results = new MatchResult(project);
lastStepResult = StepResult.Start;
initBefore = Project.EngineOptions.InitRoundBefore;
rounds = rules.Rounds;
}
public void Run <TGrid>(TGrid grid, Dictionary <Coordinate, bool> buffer,
int?iterations = null)
where TGrid : IConwayGrid
{
var result = new StepResult();
var executedIterations = 0;
while (grid.HasLiveCells())
{
Step(result, grid, buffer);
grid.SetDictionary(result.State);
result.Clear();
executedIterations++;
if (iterations != null && executedIterations >= iterations)
{
break;
}
}
}
protected override StepResult HandleResult(string result, Queue <ConfigInitWizardStep> steps, Config config, string workingDirectory)
{
switch (result)
{
case "0":
steps.Enqueue(new EditConfigStep(Console, FileSystem));
return(StepResult.Ok());
case "1":
config.AssemblyInformationalVersioningScheme = AssemblyInformationalVersioningScheme.FullInformationalVersion;
steps.Enqueue(new EditConfigStep(Console, FileSystem));
return(StepResult.Ok());
case "2":
config.AssemblyInformationalVersioningScheme = AssemblyInformationalVersioningScheme.NugetVersion;
steps.Enqueue(new EditConfigStep(Console, FileSystem));
return(StepResult.Ok());
}
return(StepResult.InvalidResponseSelected());
}
public async Task Dont_Use_Scoring_System_ReceivingPMode_When_Already_Configure()
{
// Arrange
var expected = new ReceivePMode {
Id = "static-receive-configured"
};
// Act
StepResult result = await _step.ExecuteAsync(
new MessagingContext(
AS4Message.Empty,
MessagingContextMode.Receive)
{
ReceivingPMode = expected
});
// Assert
Assert.Same(
expected,
result.MessagingContext.ReceivingPMode);
}
/// <summary>
/// Find action that does not throw error on No Such Element or Element Not Visible
/// </summary>
/// <param name="step"></param>
/// <returns>Pass = true if found, Pass = false if not found</returns>
public StepResult FindSafeAction(TestStep step)
{
StepResult r = new StepResult();
try {
Actions actions = new Actions(_driver);
actions.MoveToElement(GetBy(step.IdBy, step.IdValue));
actions.Build().Perform();
r = Pass(step);
}
catch (NoSuchElementException) {
r = Fail(step);
}
catch (ElementNotVisibleException) {
r = Fail(step);
}
catch (Exception ex) {
r = Fail(step, ex);
}
return(r);
}
static void Main(string[] args)
{
Console.SetWindowSize(60, 25);
Console.SetBufferSize(60, 1000);
while (true)
{
using (var repository = new Repository())
{
MainLogic logic = new MainLogic(repository);
StepResult result = logic.RunStep();
//вызываем у бизнес логики функцию
//так мы раньше вызывали меню
//и значение и присваиваем в переменную
if (result == StepResult.Exit)//это переписанный Userchoicecancel
{
break;
}
}
}
}
/// <summary>
/// When the node is NOT in IBD, process and push the blocks in <see cref="BlockStoreLoop.PendingStorage"/> immediately
/// to the block repository without checking batch size.
/// </summary>
private async Task <StepResult> ProcessWhenNotInIBDAsync(ProcessPendingStorageContext context)
{
this.logger.LogTrace("({0}:'{1}')", nameof(context.NextChainedBlock), context.NextChainedBlock);
while (context.CancellationToken.IsCancellationRequested == false)
{
StepResult result = this.PrepareNextBlockFromPendingStorage(context);
if (result == StepResult.Stop)
{
break;
}
}
if (context.PendingBlockPairsToStore.Any())
{
await this.PushBlocksToRepositoryAsync(context);
}
this.logger.LogTrace("(-):{0}", StepResult.Continue);
return(StepResult.Continue);
}
protected override StepResult HandleResult(string result, Queue <ConfigInitWizardStep> steps, Config config, string workingDirectory)
{
switch (result)
{
case "0":
steps.Enqueue(new ConfigureBranch(name, branchConfig, Console, FileSystem));
return(StepResult.Ok());
case "1":
branchConfig.VersioningMode = VersioningMode.ContinuousDelivery;
steps.Enqueue(new ConfigureBranch(name, branchConfig, Console, FileSystem));
return(StepResult.Ok());
case "2":
branchConfig.VersioningMode = VersioningMode.ContinuousDeployment;
steps.Enqueue(new ConfigureBranch(name, branchConfig, Console, FileSystem));
return(StepResult.Ok());
}
return(StepResult.InvalidResponseSelected());
}
public void modify_increments_with_cell_results()
{
var result = new StepResult("foo", ResultStatus.ok)
{
cells = new[]
{
CellResult.Error("a", "bad!"),
CellResult.Error("b", "worse!"),
CellResult.Success("c"),
CellResult.Failure("d", "different"),
CellResult.Failure("e", "different"),
CellResult.Failure("f", "different"),
}
};
var counts = new Counts();
result.Tabulate(counts);
counts.ShouldEqual(1, 3, 2, 0);
}
/// <summary>
/// Initializes step with the name passed.
/// </summary>
/// <param name="stepName">Name of the step.</param>
public void BeginStep(string stepName)
{
lock (_locker)
{
if (_pause)
{
System.Diagnostics.Debug.WriteLine("Begin step - pause");
DoPause();
}
_currentStepNum++;
_currentStep = new StepResult {
Number = _currentStepNum, StepName = stepName, Status = StepStatus.Passed, Message = stepName
};
if (OnStepStarted != null)
{
OnStepStarted(_currentStep);
}
}
}
/// <summary>
/// When the node disposes, process all the blocks in <see cref="BlockStoreLoop.PendingStorage"/> until
/// its empty
/// </summary>
private async Task <StepResult> ProcessWhenDisposingAsync(ProcessPendingStorageContext context)
{
this.logger.LogTrace("({0}:'{1}')", nameof(context.NextChainedBlock), context.NextChainedBlock);
while (this.BlockStoreLoop.PendingStorage.Count > 0)
{
StepResult result = this.PrepareNextBlockFromPendingStorage(context);
if (result == StepResult.Stop)
{
break;
}
}
if (context.PendingBlockPairsToStore.Any())
{
await this.PushBlocksToRepositoryAsync(context);
}
this.logger.LogTrace("(-):{0}", StepResult.Stop);
return(StepResult.Stop);
}
internal static async Task <MessagingContext> ExecuteStepsAsync(MessagingContext context, StepConfiguration stepConfig)
{
try
{
IEnumerable <IStep> steps = CreateSteps(stepConfig.NormalPipeline);
StepResult result = await ExecuteSteps(steps, context);
bool weHaveAnyUnhappyPath = stepConfig.ErrorPipeline != null;
if (result.Succeeded == false && weHaveAnyUnhappyPath && result.MessagingContext.Exception == null)
{
IEnumerable <IStep> unhappySteps = CreateSteps(stepConfig.ErrorPipeline);
result = await ExecuteSteps(unhappySteps, result.MessagingContext);
}
return(result.MessagingContext);
}
catch (Exception ex)
{
return(new MessagingContext(ex));
}
}
protected override StepResult HandleResult(string result, Queue <ConfigInitWizardStep> steps, Config config, string workingDirectory, IFileSystem fileSystem)
{
switch (result.ToLower())
{
case "y":
Console.WriteLine("GitFlow is likely a good fit, the 'develop' branch can be used " +
"for active development while stabilising the next release.");
Console.WriteLine();
Console.WriteLine("GitHubFlow is designed for a lightweight workflow where master is always " +
"good to deploy to production and feature branches are used to stabilise " +
"features, once stable they are merged to master and made available in the next release");
steps.Enqueue(new PickBranchingStrategyStep());
return(StepResult.Ok());
case "n":
steps.Enqueue(new PickBranchingStrategy3Step());
return(StepResult.Ok());
}
return(StepResult.InvalidResponseSelected());
}
public async Task <StepResult> Execute(ClientRequest request)
{
var stepResult = new StepResult();
stepResult.Step = RegistrationStep.Step1;
if (string.IsNullOrEmpty(request.Email))
{
stepResult.Errors.Add(new ValidationError(nameof(request.Email), "Null or empty"));
}
if (string.IsNullOrEmpty(request.Passowrd))
{
stepResult.Errors.Add(new ValidationError(nameof(request.Passowrd), "Null or empty"));
}
//Одна секунда
await Task.Delay(1000);
return(stepResult);
}
private static SpecResults buildResultsForContextCreationFailure(SpecExecutionRequest request, Exception ex,
Timings timings)
{
var result = new StepResult(request.Specification.id, ex)
{
position = Stage.context
};
var perf = timings.Finish();
return(new SpecResults
{
Attempts = request.Plan.Attempts,
Duration = timings.Duration,
Performance = perf.ToArray(),
Counts = new Counts(0, 0, 1, 0),
Results = new IResultMessage[]
{
result
}
});
}
public override async Task <StepResult> Do()
{
StepResult result = new StepResult();
result.ResultText = string.Empty;
try
{
result.ResultText = file.CopyTo(Path.Combine(Parameters["DestinationPath"].Value, file.Name), overwrite).FullName;
LogMessage(LogLevel.Info, string.Concat("Copied file to ", result.ResultText));
}
catch
{
LogMessage(LogLevel.Error, string.Concat("File couldn't be copied to", result.ResultText));
return(result);
}
result.Done = File.Exists(result.ResultText);
return(result);
}
/// <summary>
/// Handles "StepCompleted" event.
/// </summary>
/// <param name="result"></param>
void _td_StepCompleted(StepResult result)
{
System.ServiceModel.FaultException fault = result.Exception as System.ServiceModel.FaultException;
bool bFault = false;
if (fault != null)
{
bFault = true;
}
string stepResult = string.Format("STEP {0}", result.Status.ToString().ToUpper());
if (result.Status == StepStatus.Failed && !bFault)
{
WriteLog(result.Message, LogEntryLevel.StepDetails);
}
WriteLog(stepResult, LogEntryLevel.Step);
WriteLog(string.Empty, LogEntryLevel.Test);
DisplayStepResult(result);
}
/// <summary>
/// Start sending the AS4 Messages
/// to the consuming business application
/// </summary>
/// <param name="messagingContext"></param>
/// <returns></returns>
public async Task <StepResult> ExecuteAsync(MessagingContext messagingContext)
{
if (messagingContext == null)
{
throw new ArgumentNullException(nameof(messagingContext));
}
if (messagingContext.ReceivingPMode == null)
{
throw new InvalidOperationException(
"Unable to send DeliverMessage: no ReceivingPMode is set");
}
if (messagingContext.ReceivingPMode.MessageHandling?.DeliverInformation == null)
{
throw new InvalidOperationException(
$"Unable to send the DeliverMessage: the ReceivingPMode {messagingContext.ReceivingPMode.Id} does not contain any <DeliverInformation />." +
"Please provide a correct <DeliverInformation /> tag to indicate where the deliver message (and its attachments) should be send to.");
}
if (messagingContext.ReceivingPMode.MessageHandling.DeliverInformation.DeliverMethod?.Type == null)
{
throw new InvalidOperationException(
$"Unable to send the DeliverMessage: the ReceivingPMode {messagingContext.ReceivingPMode.Id} "
+ "does not contain any <Type/> element indicating the uploading strategy in the MessageHandling.Deliver.DeliverMethod element. "
+ "Default sending strategies are: 'FILE' and 'HTTP'. See 'Deliver Uploading' for more information");
}
Logger.Trace($"{messagingContext.LogTag} Start sending the DeliverMessage to the consuming business application...");
SendResult result =
await SendDeliverMessageAsync(
messagingContext.ReceivingPMode.MessageHandling.DeliverInformation.DeliverMethod,
messagingContext.DeliverMessage);
Logger.Trace($"{messagingContext.LogTag} Done sending the DeliverMesssage to the consuming business application");
await UpdateDeliverMessageAsync(messagingContext, result);
return(StepResult.Success(messagingContext));
}
public void AddReportStep(string description, string actualResult, StepResult stepResult, string screenShotPath)
{
string reportStepRow = string.Empty;
string replaceValue = string.Empty;
StringBuilder reportStepBuilder;
switch (stepResult)
{
case StepResult.PASS:
noOfStepsPassed++;
overAllStepsPassed++;
reportStepRow = HelperClass.rptPASSRow;
break;
case StepResult.FAIL:
noOfStepsFailed++;
overAllStepsFailed++;
reportStepRow = HelperClass.rptFAILRow;
break;
case StepResult.WARNING:
reportStepRow = HelperClass.rptWARNINGRow;
overAllWarningSteps++;
break;
}
stepNo++;
reportStepBuilder = new StringBuilder(reportStepRow);
replaceValue = "##" + "StepNoValue" + "##";
reportStepBuilder.Replace(replaceValue, Convert.ToString(stepNo));
replaceValue = "##" + "StepNoDesc" + "##";
reportStepBuilder.Replace(replaceValue, description);
replaceValue = "##" + "StepActualResult" + "##";
reportStepBuilder.Replace(replaceValue, actualResult);
if (stepResult == StepResult.FAIL)
{
replaceValue = "##" + "ScreenShotPath" + "##";
reportStepBuilder.Replace(replaceValue, screenShotPath);
}
reportBuider.Append(reportStepBuilder);
}
public async Task SelectsUserMessage_IfUserMessageMatchesCriteria()
{
// Arrange
const string expectedMpc = "message-mpc";
InsertUserMessage(expectedMpc, MessageExchangePattern.Push, Operation.ToBeSent);
InsertUserMessage("yet-another-mpc", MessageExchangePattern.Pull, Operation.DeadLettered);
InsertUserMessage(expectedMpc, MessageExchangePattern.Pull, Operation.ToBeSent);
// Act
StepResult result = await ExerciseSelection(expectedMpc);
// Assert
AS4Message as4Message = await RetrieveAS4MessageFromContext(result.MessagingContext);
UserMessage userMessage = as4Message.FirstUserMessage;
Assert.Equal(expectedMpc, userMessage.Mpc);
AssertOutMessage(userMessage.MessageId, m => Assert.True(m.Operation == Operation.Sent));
Assert.NotNull(result.MessagingContext.SendingPMode);
}
public async Task Sign_Receipt_If_ReceivingPMode_ResponseSigning_Is_Enabled()
{
// Arrange
var ctx = new MessagingContext(
AS4Message.Create(new Receipt($"receipt-{Guid.NewGuid()}", $"user-{Guid.NewGuid()}")),
MessagingContextMode.Send)
{
ReceivingPMode = new ReceivingProcessingMode
{
ReplyHandling =
{
ResponseSigning = CreateEnabledSigningInformation()
}
}
};
// Act
StepResult result = await ExerciseSigning(ctx);
// Assert
Assert.True(result.MessagingContext.AS4Message.IsSigned);
}
protected override StepResult ExecuteInternal(TContext ctx)
{
StagingCache cache = ctx.BeginStaging();
StepResult result = child.Execute(ctx);
if (result != StepResult.Positive)
{
ctx.EndStaging(cache, false);
return(result);
}
while (child.Execute(ctx) == StepResult.Positive)
{
;
}
ctx.EndStaging(cache, true, false);
ctx.AddSymbol(new Production(Name, cache.Symbols));
return(StepResult.Positive);
}
public void OneStep_HasBothSuccessAndFailStepResult_DoesntThrowException()
{
var stepper = new Stepper();
stepper.AddFirstStep(() =>
{
if (true)
{
return(StepResult.Success(1));
}
return(StepResult.Failure());
})
.Then(test =>
{
Console.WriteLine(test);
return(StepResult.Success());
});
var jobResult = stepper.RunJob();
Assert.AreEqual(false, jobResult.HasFailed);
}
protected override StepResult HandleResult(string result, Queue <ConfigInitWizardStep> steps, Config config, string workingDirectory)
{
switch (result)
{
case "1":
steps.Enqueue(new GitFlowSetupStep(Console, FileSystem));
break;
case "2":
steps.Enqueue(new GitHubFlowStep(Console, FileSystem));
break;
case "3":
steps.Enqueue(new PickBranchingStrategy1Step(Console, FileSystem));
break;
default:
return(StepResult.InvalidResponseSelected());
}
return(StepResult.Ok());
}
public void LogException(string id, Exception ex, PerfRecord record, object position = null)
{
if (id.IsEmpty())
{
id = Specification.id;
position = Stage.context;
}
Reporting.ReporterFor <ExceptionReport>().Log(ex);
ex = unwrapException(ex);
if (ex is StorytellerCriticalException)
{
HadCriticalException = true;
// TODO -- hokey. Watch if this becomes a pattern
if (ex.InnerException is MissingFixtureException)
{
LogResult(new StepResult(id, ResultStatus.invalid)
{
error = ex.InnerException.Message,
position = position
}, record);
return;
}
}
CatastrophicException = ex as StorytellerCatastrophicException;
var result = new StepResult(id, ResultStatus.error)
{
position = position
};
result.error = ExceptionFormatting.ToDisplayMessage(ex, out result.errorDisplay);
LogResult(result, record);
}
protected override StepResult HandleResult(string result, Queue <ConfigInitWizardStep> steps, Config config, string workingDirectory, IFileSystem fileSystem)
{
switch (result)
{
case "1":
config.VersioningMode = VersioningMode.ContinuousDelivery;
steps.Enqueue(returnToStep);
return(StepResult.Ok());
case "2":
config.VersioningMode = VersioningMode.ContinuousDeployment;
steps.Enqueue(returnToStep);
return(StepResult.Ok());
case "0":
case "3":
steps.Enqueue(returnToStep);
return(StepResult.Ok());
}
return(StepResult.InvalidResponseSelected());
}
protected override StepResult HandleResult(string?result, Queue <ConfigInitWizardStep> steps, Config config, string workingDirectory)
{
var editConfigStep = this.StepFactory.CreateStep <EditConfigStep>() !;
switch (result)
{
case "0":
steps.Enqueue(editConfigStep);
return(StepResult.Ok());
case "1":
GenerateBasicConfig(workingDirectory);
steps.Enqueue(editConfigStep);
return(StepResult.Ok());
case "2":
GenerateNuGetConfig(workingDirectory);
steps.Enqueue(editConfigStep);
return(StepResult.Ok());
}
return(StepResult.InvalidResponseSelected());
}
public void ResultObject_WithStoreTest()
{
var expectedValue = "Expected Value";
var storageKey = "validStoreKey";
var result = new StepResult <string>(expectedValue, true);
var resultSerd = Utils.SerializeToJSON(result);
var storeManager = Substitute.For <IStorageManager>();
storeManager.GetData(Arg.Any <S3StorageReference>()).Returns(info => resultSerd);
var context = Substitute.For <WorkflowDecisionContext>(storeManager);
context.ResultRef = storageKey;
AssertObjectEquals.PropertyValuesAreEqual(context.ResultObject, result);
Assert.Equal(expectedValue, context.ResultData);
// Checking if the GetSerializedObjectFromStore method was called with exact parameter.
storeManager.Received().GetData(Arg.Is <S3StorageReference>(x => x.StorageKey == storageKey));
}
public async Task Creates_Error_Based_On_ErrorResult_Information()
{
// Arrange
AS4Message as4Message = CreateFilledAS4Message();
var fixture = new MessagingContext(
as4Message,
MessagingContextMode.Unknown)
{
ErrorResult = new ErrorResult("error", ErrorAlias.ConnectionFailure),
ReceivingPMode = new ReceivingProcessingMode()
};
// Act
StepResult result = await CreateErrorStep().ExecuteAsync(fixture);
// Assert
var error = result.MessagingContext.AS4Message.FirstSignalMessage as Error;
Assert.NotNull(error);
Assert.Equal("message-id", error.RefToMessageId);
Assert.Equal(ErrorCode.Ebms0005, error.ErrorLines.First().ErrorCode);
}
/// <summary>
/// Execute the step for a given <paramref name="messagingContext"/>.
/// </summary>
/// <param name="messagingContext">Message used during the step execution.</param>
/// <returns></returns>
public async Task <StepResult> ExecuteAsync(MessagingContext messagingContext)
{
if (messagingContext?.AS4Message == null)
{
throw new InvalidOperationException(
$"{nameof(UpdateReceivedAS4MessageBodyStep)} requires an AS4Message to update but no AS4Message is present in the MessagingContext");
}
Logger.Trace("Updating the received message body...");
using (DatastoreContext datastoreContext = _createDatastoreContext())
{
var repository = new DatastoreRepository(datastoreContext);
var service = new InMessageService(_configuration, repository);
service.UpdateAS4MessageForMessageHandling(
messagingContext.AS4Message,
messagingContext.SendingPMode,
messagingContext.ReceivingPMode,
_messageBodyStore);
await datastoreContext.SaveChangesAsync().ConfigureAwait(false);
}
if (messagingContext.ReceivedMessageMustBeForwarded)
{
// When the Message has to be forwarded, the remaining Steps must not be executed.
// The MSH must answer with a HTTP Accepted status-code, so an empty context must be returned.
messagingContext.ModifyContext(AS4Message.Empty);
Logger.Info(
"Stops execution to return empty SOAP envelope to the orignal sender. " +
"This happens when the message must be forwarded");
return(StepResult.Success(messagingContext).AndStopExecution());
}
return(StepResult.Success(messagingContext));
}
/// <summary>
/// 获取子节点执行结果的状态
/// </summary>
private static void GetStepsResultFlag(StepTaskEntityBase stepEntry, ref bool isTimeout, ref bool isError,
ref bool isAbort, ref bool isFailed)
{
if (null == stepEntry)
{
return;
}
StepTaskEntityBase subStep = stepEntry;
while (null != subStep)
{
StepResult result = subStep.Result;
switch (result)
{
case StepResult.Failed:
isFailed = true;
break;
case StepResult.Abort:
isAbort = true;
break;
case StepResult.Timeout:
isTimeout = true;
break;
case StepResult.Error:
isError = true;
break;
default:
// ignore
break;
}
GetStepsResultFlag(subStep.SubStepRoot, ref isTimeout, ref isError, ref isAbort, ref isFailed);
subStep = subStep.NextStep;
}
}
protected virtual void EstablishContext()
{
var memStream = new MemoryStream();
var xmlWriter = new XmlTextWriter(memStream, Encoding.UTF8);
var story = new Feature("StoryTitle");
var scenarioResult = new ScenarioResult(story, "ScenarioTitle");
var actionStepResult = new StepResult(Step("Given Foo"), Passed);
scenarioResult.AddActionStepResult(actionStepResult);
var eventsReceived = new List<EventReceived>
{
new EventReceived("", EventType.RunStart),
new EventReceived("StoryTitle", EventType.FeatureStart),
new EventReceived("As a x\nI want y\nSo That z", EventType.FeatureNarrative),
new EventReceived("ScenarioTitle", EventType.ScenarioStart),
new ScenarioResultEventReceived(scenarioResult),
new EventReceived("", EventType.FeatureFinished),
new EventReceived("", EventType.RunFinished)
};
_xmlOutputWriter = new XmlOutputWriter(xmlWriter, eventsReceived);
}
public StepResult NextStep()
{
if (lastInstructionWatchMode)
{
//copy instruction
lastInstruction = NextInstruction;
}
lastStepResult = (StepResult)pMarsDll.pMarsStepMatch();
dllCoreLoaded = false;
dllTasksLoaded = false;
dllWarriorsLoaded = false;
cycle++;
if (lastStepResult > StepResult.Continue)
{
if (lastStepResult != StepResult.Finished)
{
cycle = 0;
}
else
{
pMarsDll.pMarsResultsMatch();
dllWarriorsLoaded = false;
CopyWarriors();
results.score = new int[rules.WarriorsCount];
for (int w = 0; w < rules.WarriorsCount; w++)
{
results.score[w] = warriorsDllCopy[w].totalScore;
}
}
}
return lastStepResult;
}
protected void InitRound()
{
round++;
if (round >= rounds)
{
lastStepResult = StepResult.Finished;
}
else
{
InitializeRound();
}
}
public void StepFinished(StepResult stepResult)
{
contextHandler.OnStepFinishedEvent();
if (OnStepFinished != null)
OnStepFinished(this, new EventArgs<StepResult>(stepResult));
}
protected override void EstablishContext()
{
var memStream = new MemoryStream();
var xmlWriter = new XmlTextWriter(memStream, Encoding.UTF8);
var feature = new Feature("FeatureTitle");
var scenarioResult = new ScenarioResult(feature, "ScenarioTitle");
var actionStepResult1 = new StepResult(Step("Given a"), Passed);
scenarioResult.AddActionStepResult(actionStepResult1);
var actionStepResult2 = new StepResult(Step("When b"), Passed);
scenarioResult.AddActionStepResult(actionStepResult2);
var actionStepResult3 = new StepResult(Step("Then c"), Passed);
scenarioResult.AddActionStepResult(actionStepResult3);
var eventsReceived = new List<EventReceived>
{
new EventReceived("ScenarioTitle", EventType.ScenarioStart),
new ScenarioResultEventReceived(scenarioResult)
};
_xmlOutputWriter = new XmlOutputWriter(xmlWriter, eventsReceived);
_xmlOutputWriter.DoScenario(eventsReceived[0], scenarioResult);
xmlWriter.Flush();
_xmlDoc = new XmlDocument();
memStream.Seek(0, SeekOrigin.Begin);
_xmlDoc.Load(memStream);
}
public EngineEvent(EngineInstruction executedInstruction, int cycles, int cyclesLeft, int ip, EngineWarrior warrior, StepResult prevStepResult)
{
ExecutedInstruction = executedInstruction;
Cycles = cycles;
CyclesLeft = cyclesLeft;
Ip = ip;
Warrior = warrior;
PrevStepResult = prevStepResult;
instructionsChanged = new Stack<EngineInstruction>();
}
IEnumerable<EventReceived> CreateSecondFeature()
{
var feature = new Feature("Second feature");
var scenarioResult = new ScenarioResult(feature, "ScenarioTitle");
var actionStepResult1 = new StepResult(Step("Given a"), Passed);
scenarioResult.AddActionStepResult(actionStepResult1);
var actionStepResult2 = new StepResult(Step("When b"), Passed);
scenarioResult.AddActionStepResult(actionStepResult2);
var actionStepResult3 = new StepResult(Step("Then c"), Passed);
scenarioResult.AddActionStepResult(actionStepResult3);
var eventsReceived = new List<EventReceived>
{
new EventReceived(feature.Title, EventType.FeatureStart),
new EventReceived("As a x\nI want y\nSo That z", EventType.FeatureNarrative),
new EventReceived("ScenarioTitle", EventType.ScenarioStart),
new ScenarioResultEventReceived(scenarioResult),
new EventReceived(feature.Title, EventType.FeatureFinished)
};
return eventsReceived;
}
private void CheapCheck(StepResult resOne, StepResult resTwo, Check origCheck, bool precise)
{
if (resOne != resTwo)
{
throw new EngineDifferException("StepRes",
new Check(0, origCheck.FromCycle, origCheck.ToCycle, origCheck.Step / 2));
}
if (engineOne.Cycle != engineTwo.Cycle)
{
throw new EngineDifferException("Cycle", new Check(engineOne.Round, engineOne.Cycle, precise));
}
if (engineOne.Round != engineTwo.Round)
{
throw new EngineDifferException("Round", new Check(engineOne.Round, engineOne.Cycle, precise));
}
if (engineOne.LiveWarriorsCount != engineTwo.LiveWarriorsCount)
{
throw new EngineDifferException("Died", new Check(engineOne.Round, engineOne.Cycle, precise));
}
if (engineOne.CyclesLeft != engineTwo.CyclesLeft)
{
throw new EngineDifferException("CyclesLeft", new Check(engineOne.Round, engineOne.Cycle, precise));
}
if (engineOne.NextWarriorIndex != engineTwo.NextWarriorIndex)
{
throw new EngineDifferException("Cheating", new Check(engineOne.Round, engineOne.Cycle, precise));
}
}
private string TypeAsString(StepResult stepResult)
{
if (stepResult.Result is Pending && (stepResult.Result is Skipped == false))
return "PENDING";
return stepResult.Result.ToString().ToUpper();
}
private void WriteTableSteps(StepResult stepResult)
{
if (stepResult.StringStep is StringTableStep == false)
return;
var stringTableStep = stepResult.StringStep as StringTableStep;
var heeader = stringTableStep.TableSteps.First();
writer.WriteColorString(" " + heeader.ColumnNamesToString(), GetColorForResult(stepResult.Result));
foreach (var tableStep in stringTableStep.TableSteps)
writer.WriteColorString(" " + tableStep.ColumnValuesToString(), GetColorForResult(stepResult.Result));
}
public void DoStringStep(StepResult result)
{
Writer.WriteStartElement("step");
Writer.WriteAttributeString("name", result.StringStep.ToString().TrimEnd());
Writer.WriteAttributeString("outcome", result.Result.ToString());
if (result.Result.GetType() == typeof(Failed))
Writer.WriteElementString("failure", result.Message);
if (result.StringStep is StringTableStep)
DoStringTableStep(result.StringStep as StringTableStep);
Writer.WriteEndElement();
}
