public CsvStateMachineReportGeneratorTest()
        {
            this.stateStream = new MemoryStream();
            this.transitionsStream = new MemoryStream();

            this.testee = new CsvStateMachineReportGenerator<States, Events>(this.stateStream, this.transitionsStream);
        }
Exemple #2
0
        public void Report(string dummyName, Func <string, StateMachineDefinition <States, Events>, IStateMachine <States, Events> > createStateMachine)
        {
            var stateStream       = new MemoryStream();
            var transitionsStream = new MemoryStream();

            var testee = new CsvStateMachineReportGenerator <States, Events>(stateStream, transitionsStream);

            var stateMachineDefinitionBuilder = new StateMachineDefinitionBuilder <States, Events>();

            stateMachineDefinitionBuilder
            .DefineHierarchyOn(States.Healthy)
            .WithHistoryType(HistoryType.Deep)
            .WithInitialSubState(States.OnFloor)
            .WithSubState(States.Moving);
            stateMachineDefinitionBuilder
            .DefineHierarchyOn(States.Moving)
            .WithHistoryType(HistoryType.Shallow)
            .WithInitialSubState(States.MovingUp)
            .WithSubState(States.MovingDown);
            stateMachineDefinitionBuilder
            .DefineHierarchyOn(States.OnFloor)
            .WithHistoryType(HistoryType.None)
            .WithInitialSubState(States.DoorClosed)
            .WithSubState(States.DoorOpen);
            stateMachineDefinitionBuilder
            .In(States.Healthy)
            .On(Events.ErrorOccurred).Goto(States.Error);
            stateMachineDefinitionBuilder
            .In(States.Error)
            .On(Events.Reset).Goto(States.Healthy)
            .On(Events.ErrorOccurred);
            stateMachineDefinitionBuilder
            .In(States.OnFloor)
            .ExecuteOnEntry(AnnounceFloor)
            .ExecuteOnExit(Beep)
            .ExecuteOnExit(Beep)
            .On(Events.CloseDoor).Goto(States.DoorClosed)
            .On(Events.OpenDoor).Goto(States.DoorOpen)
            .On(Events.GoUp)
            .If(CheckOverload)
            .Goto(States.MovingUp)
            .Otherwise()
            .Execute(AnnounceOverload)
            .Execute(Beep)
            .On(Events.GoDown)
            .If(CheckOverload)
            .Goto(States.MovingDown)
            .Otherwise()
            .Execute(AnnounceOverload);
            stateMachineDefinitionBuilder
            .In(States.Moving)
            .On(Events.Stop).Goto(States.OnFloor);
            var stateMachineDefinition = stateMachineDefinitionBuilder
                                         .WithInitialState(States.OnFloor)
                                         .Build();

            var elevator = createStateMachine("Elevator", stateMachineDefinition);

            elevator.Report(testee);

            string statesReport;
            string transitionsReport;

            stateStream.Position = 0;
            using (var reader = new StreamReader(stateStream))
            {
                statesReport = reader.ReadToEnd();
            }

            transitionsStream.Position = 0;
            using (var reader = new StreamReader(transitionsStream))
            {
                transitionsReport = reader.ReadToEnd();
            }

            const string ExpectedTransitionsReport = "Source;Event;Guard;Target;ActionsHealthy;ErrorOccurred;;Error;OnFloor;CloseDoor;;DoorClosed;OnFloor;OpenDoor;;DoorOpen;OnFloor;GoUp;CheckOverload;MovingUp;OnFloor;GoUp;;internal transition;AnnounceOverload, BeepOnFloor;GoDown;CheckOverload;MovingDown;OnFloor;GoDown;;internal transition;AnnounceOverloadMoving;Stop;;OnFloor;Error;Reset;;Healthy;Error;ErrorOccurred;;internal transition;";
            const string ExpectedStatesReport      = "Source;Entry;Exit;ChildrenHealthy;;;OnFloor, MovingOnFloor;AnnounceFloor;Beep, Beep;DoorClosed, DoorOpenMoving;;;MovingUp, MovingDownMovingUp;;;MovingDown;;;DoorClosed;;;DoorOpen;;;Error;;;";

            statesReport
            .IgnoringNewlines()
            .Should()
            .Be(
                ExpectedStatesReport
                .IgnoringNewlines());

            transitionsReport
            .IgnoringNewlines()
            .Should()
            .Be(
                ExpectedTransitionsReport
                .IgnoringNewlines());

            stateStream.Dispose();
        }