From 9d439306e65d04c47919ad2771866c1f97786d40 Mon Sep 17 00:00:00 2001 From: TomKovac <61820360+TomKovac@users.noreply.github.com> Date: Tue, 31 Jan 2023 16:28:15 +0100 Subject: [PATCH 1/3] additions from ptku and apax command in cake fix --- cake/BuildContext.cs | 2 +- src/core/ctrl/apax.yml | 2 +- .../src/Coordination/Sequencer/Sequencer.st | 199 ++++-- .../ctrl/src/Coordination/eSequencerStates.st | 11 - .../ctrl/test/Coordination/SequencerTests.st | 599 +++++++++++++++++- 5 files changed, 708 insertions(+), 105 deletions(-) delete mode 100644 src/core/ctrl/src/Coordination/eSequencerStates.st diff --git a/cake/BuildContext.cs b/cake/BuildContext.cs index 681468a8a..b2344ea02 100644 --- a/cake/BuildContext.cs +++ b/cake/BuildContext.cs @@ -148,7 +148,7 @@ public static void ApaxTest(this BuildContext context, (string folder, string na { context.ProcessRunner.Start(Helpers.GetApaxCommand(), new ProcessSettings() { - Arguments = "pack", + Arguments = "test", WorkingDirectory = context.GetAxFolder(lib), RedirectStandardOutput = false, RedirectStandardError = false, diff --git a/src/core/ctrl/apax.yml b/src/core/ctrl/apax.yml index d7a65476e..028b9a221 100644 --- a/src/core/ctrl/apax.yml +++ b/src/core/ctrl/apax.yml @@ -1,5 +1,5 @@ name: "@ix-ax/ix.framework.core" -version: '0.1.0-alpha.3' +version : '0.1.0-updates-from-pku-org.1' type: lib targets: - "1500" diff --git a/src/core/ctrl/src/Coordination/Sequencer/Sequencer.st b/src/core/ctrl/src/Coordination/Sequencer/Sequencer.st index bc107c609..5a168764b 100644 --- a/src/core/ctrl/src/Coordination/Sequencer/Sequencer.st +++ b/src/core/ctrl/src/Coordination/Sequencer/Sequencer.st @@ -11,7 +11,8 @@ NAMESPACE ix.framework.core StepBackwardCommand : CommandTask; END_VAR VAR PRIVATE - _configurationFlowOrder : ULINT; + _configurationFlowOrder : ULINT; + _numberOfConfiguredSteps : ULINT; _coordinatorState : CoordinatorStates; _step : IStep; _steppingMode : eSteppingMode; @@ -27,12 +28,16 @@ NAMESPACE ix.framework.core /// METHOD PUBLIC Open IF SUPER.Execute() THEN - IF THIS.InvalidContext() THEN RETURN; END_IF; + IF THIS. InvalidContext() THEN RETURN; END_IF; _openCycleCounter := THIS.GetContext().OpenCycleCount(); CASE _coordinatorState OF CoordinatorStates#Idle : _configurationFlowOrder := ULINT#0; + _numberOfConfiguredSteps := ULINT#0; _coordinatorState := CoordinatorStates#Configuring; + StepForwardCommand.Initialize(THIS.GetContext()); + StepIn.Initialize(THIS.GetContext()); + StepBackwardCommand.Initialize(THIS.GetContext()); CoordinatorStates#Configuring : CurrentOrder := ULINT#1; _coordinatorState := CoordinatorStates#Running; @@ -40,65 +45,6 @@ NAMESPACE ix.framework.core END_IF; END_METHOD - /// - /// Completes (finishes) the execution of this sequencer. - /// Returns the `order of execution` pointer to the first step of the sequence. - /// - METHOD PUBLIC CompleteSequence - IF SUPER.Execute() THEN - IF THIS.InvalidContext(_step) THEN RETURN; END_IF; - IF _coordinatorState = CoordinatorStates#Running THEN - _step.DoneWhen(TRUE); - _coordinatorState := CoordinatorStates#Idle; - CurrentOrder := ULINT#1; - SUPER.DoneWhen(_sequenceMode =eSequenceMode#RunOnce); - // Finalize the StepIn Command in a case of step mode - StepIn.DoneWhen(_steppingMode = eSteppingMode#StepByStep); - END_IF; - END_IF; - END_METHOD - - /// - /// Moves the execution to the next step. - /// - METHOD PUBLIC MoveNext - IF SUPER.Execute() THEN - IF THIS.InvalidContext(_step) THEN RETURN; END_IF; - IF _coordinatorState = CoordinatorStates#Running THEN - _step.DoneWhen(TRUE); - CurrentOrder := CurrentOrder + ULINT#1; - // Finalize the StepIn Command in a case of step mode - StepIn.DoneWhen(_steppingMode = eSteppingMode#StepByStep); - END_IF; - END_IF; - END_METHOD - - /// - /// Gets the state of the coordinator - /// - METHOD PUBLIC GetCoordinatorState : CoordinatorStates - GetCoordinatorState := _coordinatorState; - END_METHOD - - /// - /// Terminates the currently executed step and initiates the RequestedStep to be executed - /// - METHOD PUBLIC RequestStep - VAR_INPUT - RequestedStep : IStep; - END_VAR - IF SUPER.Execute() THEN - IF THIS.InvalidContext(RequestedStep) THEN RETURN; END_IF; - IF RequestedStep.GetStepOrder() <> ULINT#0 AND - _coordinatorState = CoordinatorStates#Running THEN - _step.DoneWhen(TRUE); - CurrentOrder := RequestedStep.GetStepOrder(); - // Finalize the StepIn Command in a case of step mode - StepIn.DoneWhen(_steppingMode = eSteppingMode#StepByStep); - END_IF; - END_IF; - END_METHOD - /// /// Returns `TRUE` if the specified step is currently executing. /// @@ -114,7 +60,42 @@ NAMESPACE ix.framework.core _step := step; THIS.DetermineOrder(step); - + + // Stepping inside the sequence + IF _coordinatorState = CoordinatorStates#Running THEN + // Stepping is possible only in StepByStepMode + IF _steppingMode = eSteppingMode#StepByStep THEN + // Stepping Forwards and Backwards commands cannot be executed simultaneously + StepForwardCommand.IsDisabled := StepBackwardCommand.IsBusy() + // Stepping Forwards disabled from last step + OR CurrentOrder >= _numberOfConfiguredSteps; + StepIn.IsDisabled := FALSE; + StepBackwardCommand.IsDisabled := StepForwardCommand.IsBusy() + // Stepping Backwards disabled from first step + OR CurrentOrder <= ULINT#1; + // StepForward command increments the CurrentOrder just to a maximum value of _numberOfConfiguredSteps + IF StepForwardCommand.Execute() THEN + IF CurrentOrder < _numberOfConfiguredSteps THEN + THIS.RestoreCurrentStep(); + CurrentOrder := CurrentOrder + ULINT#1; + END_IF; + StepForwardCommand.DoneWhen(TRUE); + END_IF; + // StepBackward command decrements the CurrentOrder just to a minimum value of 1 + IF StepBackwardCommand.Execute() THEN + IF CurrentOrder > ULINT#1 THEN + THIS.RestoreCurrentStep(); + CurrentOrder := CurrentOrder - ULINT#1; + END_IF; + StepBackwardCommand.DoneWhen(TRUE); + END_IF; + ELSE + THIS.DisableAllSteppingComands(); + END_IF; + ELSE + THIS.DisableAllSteppingComands(); + END_IF; + IF _coordinatorState = CoordinatorStates#Running AND (CurrentOrder = step.GetStepOrder()) AND step.IsCalledJustOnceInThisPlcCycle() THEN IF Enable THEN step.SetIsActive(TRUE); @@ -146,8 +127,70 @@ NAMESPACE ix.framework.core Execute := step.Execute(); END_IF; - END_METHOD - + END_METHOD + + /// + /// Moves the execution to the next step. + /// + METHOD PUBLIC MoveNext + IF SUPER.Execute() THEN + IF THIS.InvalidContext(_step) THEN RETURN; END_IF; + IF _coordinatorState = CoordinatorStates#Running THEN + _step.DoneWhen(TRUE); + _step.SetIsActive(FALSE); + CurrentOrder := CurrentOrder + ULINT#1; + // Finalize the StepIn Command in a case of step mode + StepIn.DoneWhen(_steppingMode = eSteppingMode#StepByStep); + END_IF; + END_IF; + END_METHOD + + /// + /// Terminates the currently executed step and initiates the RequestedStep to be executed + /// + METHOD PUBLIC RequestStep + VAR_INPUT + RequestedStep : IStep; + END_VAR + IF SUPER.Execute() THEN + IF THIS.InvalidContext(RequestedStep) THEN RETURN; END_IF; + IF RequestedStep.GetStepOrder() <> ULINT#0 AND + _coordinatorState = CoordinatorStates#Running THEN + _step.DoneWhen(TRUE); + _step.SetIsActive(FALSE); + CurrentOrder := RequestedStep.GetStepOrder(); + // Finalize the StepIn Command in a case of step mode + StepIn.DoneWhen(_steppingMode = eSteppingMode#StepByStep); + END_IF; + END_IF; + END_METHOD + + /// + /// Completes (finishes) the execution of this sequencer. + /// Returns the `order of execution` pointer to the first step of the sequence. + /// + METHOD PUBLIC CompleteSequence + IF SUPER.Execute() THEN + IF THIS.InvalidContext(_step) THEN RETURN; END_IF; + IF _coordinatorState = CoordinatorStates#Running THEN + _step.DoneWhen(TRUE); + _step.SetIsActive(FALSE); + _coordinatorState := CoordinatorStates#Idle; + CurrentOrder := ULINT#1; + SUPER.DoneWhen(_sequenceMode =eSequenceMode#RunOnce); + // Finalize the StepIn Command in a case of step mode + StepIn.DoneWhen(_steppingMode = eSteppingMode#StepByStep); + END_IF; + END_IF; + END_METHOD + + /// + /// Gets the state of the coordinator + /// + METHOD PUBLIC GetCoordinatorState : CoordinatorStates + GetCoordinatorState := _coordinatorState; + END_METHOD + /// /// Sets the stepping mode of the sequencer /// @@ -191,6 +234,7 @@ NAMESPACE ix.framework.core step.Restore(); _step := step; _configurationFlowOrder := _configurationFlowOrder + ULINT#1; + _numberOfConfiguredSteps := _configurationFlowOrder; step.SetStepOrder(THIS,_configurationFlowOrder); IF NOT step.IsCalledJustOnceInThisPlcCycle() THEN @@ -202,6 +246,15 @@ NAMESPACE ix.framework.core DetermineOrder := step.GetStepOrder(); END_METHOD + METHOD PUBLIC GetNumberOfConfiguredSteps : ULINT + IF _coordinatorState = CoordinatorStates#Running THEN + _numberOfConfiguredSteps := _configurationFlowOrder; + GetNumberOfConfiguredSteps := _numberOfConfiguredSteps; + ELSE + GetNumberOfConfiguredSteps := ULINT#0; + END_IF; + END_METHOD + METHOD PROTECTED InvalidContext : BOOL IF THIS.GetContext() = NULL THEN InvalidContext := TRUE; // TODO: We will need to message this, when messaging ready. @@ -222,6 +275,24 @@ NAMESPACE ix.framework.core InvalidContext := FALSE; END_IF; END_METHOD + + METHOD INTERNAL DisableAllSteppingComands + StepForwardCommand.IsDisabled := TRUE; + StepIn.IsDisabled := TRUE; + StepBackwardCommand.IsDisabled := TRUE; + END_METHOD + + METHOD INTERNAL RestoreCurrentStep + // Restore current step if running + IF _step.IsBusy() THEN + _step.Restore(); + END_IF; + // Restore step in command if running, otherwise this commnad will be executed on the following step + IF StepIn.IsBusy() THEN + StepIn.Restore(); + END_IF; + _step.SetIsActive(FALSE); + END_METHOD END_CLASS END_NAMESPACE diff --git a/src/core/ctrl/src/Coordination/eSequencerStates.st b/src/core/ctrl/src/Coordination/eSequencerStates.st deleted file mode 100644 index 626864fad..000000000 --- a/src/core/ctrl/src/Coordination/eSequencerStates.st +++ /dev/null @@ -1,11 +0,0 @@ -NAMESPACE ix.framework.core - TYPE PUBLIC - eSequencerStates : INT - ( - Idle :=0, - RunningStepMode := 1, - RunningCycleMode := 2, - Error := 10 - ) := Idle; - END_TYPE -END_NAMESPACE \ No newline at end of file diff --git a/src/core/ctrl/test/Coordination/SequencerTests.st b/src/core/ctrl/test/Coordination/SequencerTests.st index b49d8bd4a..ae376265f 100644 --- a/src/core/ctrl/test/Coordination/SequencerTests.st +++ b/src/core/ctrl/test/Coordination/SequencerTests.st @@ -108,16 +108,33 @@ NAMESPACE ix.core.sequencer_tests _context.Close(); END_METHOD - METHOD PRIVATE ExecuteSequenceUpToStep_3 + METHOD PRIVATE ExecuteSequence + VAR_INPUT + CompleteStep : BOOL; + CompleteSequence : BOOL; + END_VAR + THIS.PrepareSequence(); _context.Open(); _sequencer.Open(); - _step_1.Execute(_sequencer); - _sequencer.MoveNext(); - _step_2.Execute(_sequencer); - _sequencer.MoveNext(); - _step_3.Execute(_sequencer); + + IF _step_1.Execute(_sequencer) THEN + IF CompleteStep THEN + _sequencer.MoveNext(); + END_IF; + END_IF; + IF _step_2.Execute(_sequencer) THEN + IF CompleteStep THEN + _sequencer.MoveNext(); + END_IF; + END_IF; + IF _step_3.Execute(_sequencer) THEN + IF CompleteSequence THEN + _sequencer.CompleteSequence(); + END_IF; + END_IF; + _context.Close(); END_METHOD {Test} @@ -605,7 +622,7 @@ NAMESPACE ix.core.sequencer_tests {Test} METHOD PUBLIC CompleteSequence_should_set_currently_executed_step_to_Done - THIS.ExecuteSequenceUpToStep_3(); + THIS.ExecuteSequence(TRUE,FALSE); Assert.Equal(FALSE, _step_3.IsDone()); _sequencer.CompleteSequence(); Assert.Equal(TRUE, _step_3.IsDone()); @@ -613,7 +630,7 @@ NAMESPACE ix.core.sequencer_tests {Test} METHOD PUBLIC CompleteSequence_should_reset_the_Busy_state_of_the_currently_executed_step - THIS.ExecuteSequenceUpToStep_3(); + THIS.ExecuteSequence(TRUE,FALSE); Assert.Equal(TRUE, _step_3.IsBusy()); _sequencer.CompleteSequence(); Assert.Equal(FALSE, _step_3.IsBusy()); @@ -621,21 +638,21 @@ NAMESPACE ix.core.sequencer_tests {Test} METHOD PUBLIC CompleteSequence_should_set_the_Current_Order_to_1 - THIS.ExecuteSequenceUpToStep_3(); + THIS.ExecuteSequence(TRUE,FALSE); _sequencer.CompleteSequence(); Assert.Equal(ULINT#1, _sequencer.CurrentOrder); END_METHOD {Test} METHOD PUBLIC CompleteSequence_should_set_the_coordinator_state_to_Idle - THIS.ExecuteSequenceUpToStep_3(); + THIS.ExecuteSequence(TRUE,FALSE); _sequencer.CompleteSequence(); Assert.Equal(TRUE, THIS.Equal(CoordinatorStates#Idle , _sequencer.GetCoordinatorState())); END_METHOD {Test} METHOD PUBLIC CompleteSequence_should_set_the_first_step_in_the_sequence_as_active_after_two_PLC_cycle - THIS.ExecuteSequenceUpToStep_3(); + THIS.ExecuteSequence(TRUE,FALSE); Assert.Equal(TRUE, _step_3.IsBusy()); _sequencer.CompleteSequence(); _context.Close(); @@ -763,7 +780,7 @@ NAMESPACE ix.core.sequencer_tests {Test} METHOD PUBLIC sequence_should_be_in_configuring_state_after_complete_sequence_and_all_steps_should_be_restored - THIS.ExecuteSequenceUpToStep_3(); + THIS.ExecuteSequence(TRUE,FALSE); _sequencer.CompleteSequence(); _context.Close(); @@ -842,7 +859,7 @@ NAMESPACE ix.core.sequencer_tests {Test} METHOD PUBLIC RunOnce_mode_CompleteSequence_should_set_currently_executed_step_to_Done - THIS.ExecuteSequenceUpToStep_3(); + THIS.ExecuteSequence(TRUE,FALSE); _sequencer.SetSequenceMode(eSequenceMode#RunOnce); Assert.Equal(FALSE, _step_3.IsDone()); _sequencer.CompleteSequence(); @@ -851,7 +868,7 @@ NAMESPACE ix.core.sequencer_tests {Test} METHOD PUBLIC RunOnce_mode_CompleteSequence_should_reset_the_Busy_state_of_the_currently_executed_step - THIS.ExecuteSequenceUpToStep_3(); + THIS.ExecuteSequence(TRUE,FALSE); _sequencer.SetSequenceMode(eSequenceMode#RunOnce); Assert.Equal(TRUE, _step_3.IsBusy()); _sequencer.CompleteSequence(); @@ -860,7 +877,7 @@ NAMESPACE ix.core.sequencer_tests {Test} METHOD PUBLIC RunOnce_mode_CompleteSequence_should_set_the_Current_Order_to_1 - THIS.ExecuteSequenceUpToStep_3(); + THIS.ExecuteSequence(TRUE,FALSE); _sequencer.SetSequenceMode(eSequenceMode#RunOnce); _sequencer.CompleteSequence(); Assert.Equal(ULINT#1, _sequencer.CurrentOrder); @@ -868,32 +885,25 @@ NAMESPACE ix.core.sequencer_tests {Test} METHOD PUBLIC RunOnce_mode_CompleteSequence_should_set_the_coordinator_state_to_Idle - THIS.ExecuteSequenceUpToStep_3(); + THIS.ExecuteSequence(TRUE,FALSE); _sequencer.SetSequenceMode(eSequenceMode#RunOnce); _sequencer.CompleteSequence(); Assert.Equal(TRUE, THIS.Equal(CoordinatorStates#Idle , _sequencer.GetCoordinatorState())); END_METHOD {Test} - METHOD PUBLIC RunOnce_mode_CompleteSequence_should_set_the_first_step_in_the_sequence_as_active_in_the_next_PLC_cycle - THIS.ExecuteSequenceUpToStep_3(); + METHOD PUBLIC RunOnce_mode_CompleteSequence_should_set_the_CurrentOrder_to_1 + THIS.ExecuteSequence(TRUE,FALSE); _sequencer.SetSequenceMode(eSequenceMode#RunOnce); _sequencer.CompleteSequence(); _context.Close(); - _context.Open(); - _sequencer.Open(); - - Assert.Equal(FALSE, _step_1.Execute(_sequencer)); - Assert.Equal(FALSE, _step_2.Execute(_sequencer)); - Assert.Equal(FALSE, _step_3.Execute(_sequencer)); - Assert.Equal(TRUE , _step_1.IsActive); - _context.Close(); + Assert.Equal(ULINT#1, _sequencer.CurrentOrder); END_METHOD {Test} METHOD PUBLIC RunOnce_mode_CompleteSequence_should_stops_the_execution_of_the_active_step_in_the_next_PLC_cycles - THIS.ExecuteSequenceUpToStep_3(); + THIS.ExecuteSequence(TRUE,FALSE); _sequencer.SetSequenceMode(eSequenceMode#RunOnce); _sequencer.CompleteSequence(); _context.Close(); @@ -915,7 +925,7 @@ NAMESPACE ix.core.sequencer_tests {Test} METHOD PUBLIC RunOnce_mode_CompleteSequence_coordinator_state_should_stay_in_Idle_in_the_next_PLC_cycles - THIS.ExecuteSequenceUpToStep_3(); + THIS.ExecuteSequence(TRUE,FALSE); _sequencer.SetSequenceMode(eSequenceMode#RunOnce); _sequencer.CompleteSequence(); _context.Close(); @@ -936,6 +946,539 @@ NAMESPACE ix.core.sequencer_tests Assert.Equal(TRUE, THIS.Equal(CoordinatorStates#Idle , _sequencer.GetCoordinatorState())); _context.Close(); END_METHOD + + {Test} + METHOD PUBLIC should_return_number_of_steps_in_our_case_three + THIS.ExecuteSequence(TRUE,FALSE); + Assert.Equal(ULINT#3, _sequencer.GetNumberOfConfiguredSteps()); + END_METHOD + + {Test} + METHOD PUBLIC all_stepping_commands_should_be_disabled_when_StepByStep_mode_is_not_running + THIS.ExecuteSequence(TRUE,FALSE); + Assert.Equal(TRUE,_sequencer.StepForwardCommand.IsDisabled); + Assert.Equal(TRUE,_sequencer.StepIn.IsDisabled); + Assert.Equal(TRUE,_sequencer.StepBackwardCommand.IsDisabled); + END_METHOD + + {Test} + METHOD PUBLIC all_stepping_commands_should_be_disabled_when_Sequencer_is_not_running_mode + _sequencer.SetSteppingMode(eSteppingMode#StepByStep); + Assert.Equal(TRUE ,THIS.Equal(_sequencer.GetSteppingMode(), eSteppingMode#StepByStep)); + THIS.PrepareSequence(); + Assert.Equal(TRUE, THIS.Equal(CoordinatorStates#Configuring , _sequencer.GetCoordinatorState())); + Assert.Equal(TRUE,_sequencer.StepForwardCommand.IsDisabled); + Assert.Equal(TRUE,_sequencer.StepIn.IsDisabled); + Assert.Equal(TRUE,_sequencer.StepBackwardCommand.IsDisabled); + END_METHOD + + {Test} + METHOD PUBLIC StepForward_and_StepIn_commands_should_not_be_disabled_when_Sequencer_is_running_mode + _sequencer.SetSteppingMode(eSteppingMode#StepByStep); + Assert.Equal(TRUE ,THIS.Equal(_sequencer.GetSteppingMode(), eSteppingMode#StepByStep)); + THIS.ExecuteSequence(TRUE,TRUE); + Assert.Equal(TRUE, THIS.Equal(CoordinatorStates#Running , _sequencer.GetCoordinatorState())); + Assert.Equal(FALSE,_sequencer.StepForwardCommand.IsDisabled); + Assert.Equal(FALSE,_sequencer.StepIn.IsDisabled); + END_METHOD + + {Test} + METHOD PUBLIC StepBackward_command_should_not_be_disabled_when_Sequencer_is_running_mode_and_CurrentOrder_is_greather_then_one + _sequencer.SetSteppingMode(eSteppingMode#StepByStep); + Assert.Equal(TRUE ,THIS.Equal(_sequencer.GetSteppingMode(), eSteppingMode#StepByStep)); + THIS.ExecuteSequence(TRUE,TRUE); + _sequencer.RequestStep(_step_2); + THIS.ExecuteSequence(TRUE,TRUE); + Assert.Equal(TRUE, THIS.Equal(CoordinatorStates#Running , _sequencer.GetCoordinatorState())); + Assert.Equal(FALSE,_sequencer.StepBackwardCommand.IsDisabled); + END_METHOD + + {Test} + METHOD PUBLIC StepInCommand_should_invoke_the_current_step + // Arrange + _sequencer.SetSteppingMode(eSteppingMode#StepByStep); + Assert.Equal(TRUE ,THIS.Equal(_sequencer.GetSteppingMode(), eSteppingMode#StepByStep)); + THIS.ExecuteSequence(FALSE,FALSE); + Assert.Equal(ULINT#1, _sequencer.CurrentOrder); + Assert.Equal(TRUE,_step_1.IsActive); + Assert.Equal(TRUE,_step_1.IsReady()); + Assert.Equal(FALSE,_step_1.IsBusy()); + Assert.Equal(FALSE,_step_1.IsDone()); + Assert.Equal(FALSE,_sequencer.StepIn.IsBusy()); + Assert.Equal(FALSE,_sequencer.StepIn.IsDone()); + + // Act + _sequencer.StepIn.Invoke(); + THIS.ExecuteSequence(FALSE,FALSE); + + // Assert + Assert.Equal(TRUE ,_step_1.IsActive); + Assert.Equal(FALSE,_step_1.IsReady()); + Assert.Equal(TRUE ,_step_1.IsBusy()); + Assert.Equal(FALSE,_step_1.IsDone()); + Assert.Equal(TRUE ,_sequencer.StepIn.IsBusy()); + Assert.Equal(FALSE,_sequencer.StepIn.IsDone()); + END_METHOD + + {Test} + METHOD PUBLIC StepInCommand_should_invoke_the_current_step_if_Current_step_is_Done_StepIn_should_be_also_Done + // Arrange + _sequencer.SetSteppingMode(eSteppingMode#StepByStep); + Assert.Equal(TRUE ,THIS.Equal(_sequencer.GetSteppingMode(), eSteppingMode#StepByStep)); + THIS.ExecuteSequence(TRUE,FALSE); + Assert.Equal(ULINT#1, _sequencer.CurrentOrder); + Assert.Equal(TRUE,_step_1.IsActive); + Assert.Equal(TRUE,_step_1.IsReady()); + Assert.Equal(FALSE,_step_1.IsBusy()); + Assert.Equal(FALSE,_step_1.IsDone()); + Assert.Equal(FALSE,_sequencer.StepIn.IsBusy()); + Assert.Equal(FALSE,_sequencer.StepIn.IsDone()); + + // Act + _sequencer.StepIn.Invoke(); + THIS.ExecuteSequence(TRUE,FALSE); + + // Assert + Assert.Equal(FALSE,_step_1.IsActive); + Assert.Equal(FALSE,_step_1.IsReady()); + Assert.Equal(FALSE,_step_1.IsBusy()); + Assert.Equal(TRUE ,_step_1.IsDone()); + Assert.Equal(FALSE,_sequencer.StepIn.IsBusy()); + Assert.Equal(TRUE ,_sequencer.StepIn.IsDone()); + END_METHOD + + {Test} + METHOD PUBLIC when_step_by_step_mode_is_switched_on_during_any_step_execution_this_step_should_continue_its_execution + // Arrange + THIS.ExecuteSequence(FALSE,FALSE); + Assert.Equal(ULINT#1, _sequencer.CurrentOrder); + Assert.Equal(TRUE ,_step_1.IsActive); + Assert.Equal(FALSE,_step_1.IsReady()); + Assert.Equal(TRUE ,_step_1.IsBusy()); + Assert.Equal(FALSE,_step_1.IsDone()); + + Assert.Equal(FALSE,_step_2.IsActive); + Assert.Equal(FALSE,_step_2.IsReady()); + Assert.Equal(FALSE,_step_2.IsBusy()); + Assert.Equal(FALSE,_step_2.IsDone()); + + // Act + _sequencer.SetSteppingMode(eSteppingMode#StepByStep); + Assert.Equal(TRUE ,THIS.Equal(_sequencer.GetSteppingMode(), eSteppingMode#StepByStep)); + THIS.ExecuteSequence(TRUE,FALSE); + + // Assert + Assert.Equal(FALSE,_step_1.IsActive); + Assert.Equal(FALSE,_step_1.IsReady()); + Assert.Equal(FALSE,_step_1.IsBusy()); + Assert.Equal(TRUE ,_step_1.IsDone()); + + Assert.Equal(TRUE ,_step_2.IsActive); + Assert.Equal(TRUE ,_step_2.IsReady()); + Assert.Equal(FALSE,_step_2.IsBusy()); + Assert.Equal(FALSE,_step_2.IsDone()); + END_METHOD + + {Test} + METHOD PUBLIC StepForward + VAR + _previousOrder : ULINT; + END_VAR + // Arrange + _sequencer.SetSteppingMode(eSteppingMode#StepByStep); + THIS.ExecuteSequence(FALSE,FALSE); + _sequencer.StepIn.Invoke(); + THIS.ExecuteSequence(FALSE,FALSE); + + Assert.Equal(TRUE ,_sequencer.StepForwardCommand.IsReady()); + Assert.Equal(FALSE,_sequencer.StepForwardCommand.IsBusy()); + Assert.Equal(FALSE,_sequencer.StepForwardCommand.IsDone()); + + Assert.Equal(FALSE,_sequencer.StepIn.IsReady()); + Assert.Equal(TRUE ,_sequencer.StepIn.IsBusy()); + Assert.Equal(FALSE,_sequencer.StepIn.IsDone()); + + Assert.Equal(TRUE ,_step_1.IsActive); + Assert.Equal(FALSE,_step_1.IsReady()); + Assert.Equal(TRUE ,_step_1.IsBusy()); + Assert.Equal(FALSE,_step_1.IsDone()); + + Assert.Equal(FALSE,_step_2.IsActive); + Assert.Equal(FALSE,_step_2.IsReady()); + Assert.Equal(FALSE,_step_2.IsBusy()); + Assert.Equal(FALSE,_step_2.IsDone()); + + _previousOrder := _sequencer.CurrentOrder; + + // Act + _context.Open(); + _sequencer.Open(); + _sequencer.StepForwardCommand.Invoke(); + Assert.Equal(FALSE,_sequencer.StepForwardCommand.IsReady()); + Assert.Equal(FALSE,_sequencer.StepForwardCommand.IsBusy()); + Assert.Equal(FALSE,_sequencer.StepForwardCommand.IsDone()); + _step_1.Execute(_sequencer); + Assert.Equal(FALSE,_sequencer.StepForwardCommand.IsReady()); + Assert.Equal(FALSE,_sequencer.StepForwardCommand.IsBusy()); + Assert.Equal(TRUE ,_sequencer.StepForwardCommand.IsDone()); + _step_2.Execute(_sequencer); + _step_3.Execute(_sequencer); + + // Assert + Assert.Equal(FALSE,_step_1.IsActive); + Assert.Equal(FALSE,_step_1.IsReady()); + Assert.Equal(FALSE,_step_1.IsBusy()); + Assert.Equal(FALSE,_step_1.IsDone()); + + Assert.Equal(TRUE ,_step_2.IsActive); + Assert.Equal(TRUE ,_step_2.IsReady()); + Assert.Equal(FALSE,_step_2.IsBusy()); + Assert.Equal(FALSE,_step_2.IsDone()); + + Assert.Equal(_previousOrder + ULINT#1 ,_sequencer.CurrentOrder); + END_METHOD + + {Test} + METHOD PUBLIC StepForward_should_restore_the_currently_executing_step + // Arrange + _sequencer.SetSteppingMode(eSteppingMode#StepByStep); + THIS.ExecuteSequence(FALSE,FALSE); + _sequencer.StepIn.Invoke(); + THIS.ExecuteSequence(FALSE,FALSE); + + Assert.Equal(TRUE ,_step_1.IsActive); + Assert.Equal(FALSE,_step_1.IsReady()); + Assert.Equal(TRUE ,_step_1.IsBusy()); + Assert.Equal(FALSE,_step_1.IsDone()); + + // Act + _context.Open(); + _sequencer.Open(); + _sequencer.StepForwardCommand.Invoke(); + _step_1.Execute(_sequencer); + _step_2.Execute(_sequencer); + _step_3.Execute(_sequencer); + _context.Close(); + + // Assert + Assert.Equal(FALSE,_step_1.IsActive); + Assert.Equal(FALSE,_step_1.IsReady()); + Assert.Equal(FALSE,_step_1.IsBusy()); + Assert.Equal(FALSE,_step_1.IsDone()); + END_METHOD + + {Test} + METHOD PUBLIC StepForward_should_prepare_following_step_to_be_ready_to_execute + // Arrange + _sequencer.SetSteppingMode(eSteppingMode#StepByStep); + THIS.ExecuteSequence(FALSE,FALSE); + _sequencer.StepIn.Invoke(); + THIS.ExecuteSequence(FALSE,FALSE); + + Assert.Equal(FALSE,_step_2.IsActive); + Assert.Equal(FALSE,_step_2.IsReady()); + Assert.Equal(FALSE,_step_2.IsBusy()); + Assert.Equal(FALSE,_step_2.IsDone()); + + // Act + _context.Open(); + _sequencer.Open(); + _sequencer.StepForwardCommand.Invoke(); + _step_1.Execute(_sequencer); + _step_2.Execute(_sequencer); + _step_3.Execute(_sequencer); + + // Assert + Assert.Equal(TRUE ,_step_2.IsActive); + Assert.Equal(TRUE ,_step_2.IsReady()); + Assert.Equal(FALSE,_step_2.IsBusy()); + Assert.Equal(FALSE,_step_2.IsDone()); + END_METHOD + + {Test} + METHOD PUBLIC StepForward_command_should_be_in_done_state_after_succesfull_execution + // Arrange + _sequencer.SetSteppingMode(eSteppingMode#StepByStep); + THIS.ExecuteSequence(FALSE,FALSE); + _sequencer.StepIn.Invoke(); + THIS.ExecuteSequence(FALSE,FALSE); + + Assert.Equal(TRUE ,_sequencer.StepForwardCommand.IsReady()); + Assert.Equal(FALSE,_sequencer.StepForwardCommand.IsBusy()); + Assert.Equal(FALSE,_sequencer.StepForwardCommand.IsDone()); + + // Act + _context.Open(); + _sequencer.Open(); + _sequencer.StepForwardCommand.Invoke(); + + //Assert + Assert.Equal(FALSE,_sequencer.StepForwardCommand.IsReady()); + Assert.Equal(FALSE,_sequencer.StepForwardCommand.IsBusy()); + Assert.Equal(FALSE,_sequencer.StepForwardCommand.IsDone()); + _step_1.Execute(_sequencer); + Assert.Equal(FALSE,_sequencer.StepForwardCommand.IsReady()); + Assert.Equal(FALSE,_sequencer.StepForwardCommand.IsBusy()); + Assert.Equal(TRUE ,_sequencer.StepForwardCommand.IsDone()); + END_METHOD + + {Test} + METHOD PUBLIC StepForward_command_should_increment_Current_order_if_its_value_is_lower_then_number_of_steps + VAR + _previousOrder : ULINT; + END_VAR + // Arrange + _sequencer.SetSteppingMode(eSteppingMode#StepByStep); + THIS.ExecuteSequence(FALSE,FALSE); + _sequencer.StepIn.Invoke(); + THIS.ExecuteSequence(FALSE,FALSE); + _previousOrder := _sequencer.CurrentOrder; + + // Act + _context.Open(); + _sequencer.Open(); + _sequencer.StepForwardCommand.Invoke(); + _step_1.Execute(_sequencer); + _step_2.Execute(_sequencer); + _step_3.Execute(_sequencer); + _context.Close(); + + //Assert + Assert.Equal(_previousOrder + ULINT#1,_sequencer.CurrentOrder); + END_METHOD + + {Test} + METHOD PUBLIC StepForward_command_should_not_increment_Current_order_if_its_value_is_equal_to_number_of_steps + VAR + _previousOrder : ULINT; + END_VAR + // Arrange + _sequencer.SetSteppingMode(eSteppingMode#StepByStep); + THIS.ExecuteSequence(FALSE,FALSE); + _sequencer.RequestStep(_step_3); + _sequencer.StepIn.Invoke(); + THIS.ExecuteSequence(FALSE,FALSE); + _previousOrder := _sequencer.CurrentOrder; + + // Act + _context.Open(); + _sequencer.Open(); + _sequencer.StepForwardCommand.Invoke(); + _step_1.Execute(_sequencer); + _step_2.Execute(_sequencer); + _step_3.Execute(_sequencer); + _context.Close(); + + //Assert + Assert.Equal(_previousOrder,_sequencer.CurrentOrder); + END_METHOD + + {Test} + METHOD PUBLIC StepForward_command_should_be_disabled_when_CurrentOrder_is_equal_to_last_step_order + _sequencer.SetSteppingMode(eSteppingMode#StepByStep); + THIS.ExecuteSequence(FALSE,FALSE); + _sequencer.RequestStep(_step_3); + THIS.ExecuteSequence(FALSE,FALSE); + + Assert.Equal(ULINT#3,_sequencer.CurrentOrder); + Assert.Equal(TRUE ,_sequencer.StepForwardCommand.IsDisabled); + Assert.Equal(FALSE,_sequencer.StepForwardCommand.IsReady()); + Assert.Equal(FALSE,_sequencer.StepForwardCommand.IsBusy()); + Assert.Equal(FALSE,_sequencer.StepForwardCommand.IsDone()); + END_METHOD + + {Test} + METHOD PUBLIC StepBackward + VAR + _previousOrder : ULINT; + END_VAR + // Arrange + _sequencer.SetSteppingMode(eSteppingMode#StepByStep); + THIS.ExecuteSequence(FALSE,FALSE); + _sequencer.RequestStep(_step_3); + _sequencer.StepIn.Invoke(); + THIS.ExecuteSequence(FALSE,FALSE); + + Assert.Equal(TRUE ,_sequencer.StepBackwardCommand.IsReady()); + Assert.Equal(FALSE,_sequencer.StepBackwardCommand.IsBusy()); + Assert.Equal(FALSE,_sequencer.StepBackwardCommand.IsDone()); + + Assert.Equal(FALSE,_sequencer.StepIn.IsReady()); + Assert.Equal(TRUE ,_sequencer.StepIn.IsBusy()); + Assert.Equal(FALSE,_sequencer.StepIn.IsDone()); + + Assert.Equal(TRUE ,_step_3.IsActive); + Assert.Equal(FALSE,_step_3.IsReady()); + Assert.Equal(TRUE ,_step_3.IsBusy()); + Assert.Equal(FALSE,_step_3.IsDone()); + + Assert.Equal(FALSE,_step_2.IsActive); + Assert.Equal(FALSE,_step_2.IsReady()); + Assert.Equal(FALSE,_step_2.IsBusy()); + Assert.Equal(FALSE,_step_2.IsDone()); + + _previousOrder := _sequencer.CurrentOrder; + + // Act + _context.Open(); + _sequencer.Open(); + _sequencer.StepBackwardCommand.Invoke(); + Assert.Equal(FALSE,_sequencer.StepBackwardCommand.IsReady()); + Assert.Equal(FALSE,_sequencer.StepBackwardCommand.IsBusy()); + Assert.Equal(FALSE,_sequencer.StepBackwardCommand.IsDone()); + _step_1.Execute(_sequencer); + Assert.Equal(FALSE,_sequencer.StepBackwardCommand.IsReady()); + Assert.Equal(FALSE,_sequencer.StepBackwardCommand.IsBusy()); + Assert.Equal(TRUE ,_sequencer.StepBackwardCommand.IsDone()); + _step_2.Execute(_sequencer); + _step_3.Execute(_sequencer); + + // Assert + Assert.Equal(FALSE,_step_3.IsActive); + Assert.Equal(FALSE,_step_3.IsReady()); + Assert.Equal(FALSE,_step_3.IsBusy()); + Assert.Equal(FALSE,_step_3.IsDone()); + + Assert.Equal(TRUE ,_step_2.IsActive); + Assert.Equal(TRUE ,_step_2.IsReady()); + Assert.Equal(FALSE,_step_2.IsBusy()); + Assert.Equal(FALSE,_step_2.IsDone()); + + Assert.Equal(_previousOrder - ULINT#1 ,_sequencer.CurrentOrder); + END_METHOD + + {Test} + METHOD PUBLIC StepBackward_should_restore_the_currently_executing_step + VAR + _previousOrder : ULINT; + END_VAR + // Arrange + _sequencer.SetSteppingMode(eSteppingMode#StepByStep); + THIS.ExecuteSequence(FALSE,FALSE); + _sequencer.RequestStep(_step_3); + _sequencer.StepIn.Invoke(); + THIS.ExecuteSequence(FALSE,FALSE); + + Assert.Equal(TRUE ,_step_3.IsActive); + Assert.Equal(FALSE,_step_3.IsReady()); + Assert.Equal(TRUE ,_step_3.IsBusy()); + Assert.Equal(FALSE,_step_3.IsDone()); + + // Act + _context.Open(); + _sequencer.Open(); + _sequencer.StepBackwardCommand.Invoke(); + _step_1.Execute(_sequencer); + _step_2.Execute(_sequencer); + _step_3.Execute(_sequencer); + + // Assert + Assert.Equal(FALSE,_step_3.IsActive); + Assert.Equal(FALSE,_step_3.IsReady()); + Assert.Equal(FALSE,_step_3.IsBusy()); + Assert.Equal(FALSE,_step_3.IsDone()); + END_METHOD + + {Test} + METHOD PUBLIC StepBackward_should_prepare_previous_step_to_be_ready_to_execute + VAR + _previousOrder : ULINT; + END_VAR + // Arrange + _sequencer.SetSteppingMode(eSteppingMode#StepByStep); + THIS.ExecuteSequence(FALSE,FALSE); + _sequencer.RequestStep(_step_3); + _sequencer.StepIn.Invoke(); + THIS.ExecuteSequence(FALSE,FALSE); + + Assert.Equal(FALSE,_step_2.IsActive); + Assert.Equal(FALSE,_step_2.IsReady()); + Assert.Equal(FALSE,_step_2.IsBusy()); + Assert.Equal(FALSE,_step_2.IsDone()); + + // Act + _context.Open(); + _sequencer.Open(); + _sequencer.StepBackwardCommand.Invoke(); + _step_1.Execute(_sequencer); + _step_2.Execute(_sequencer); + _step_3.Execute(_sequencer); + + // Assert + Assert.Equal(TRUE ,_step_2.IsActive); + Assert.Equal(TRUE ,_step_2.IsReady()); + Assert.Equal(FALSE,_step_2.IsBusy()); + Assert.Equal(FALSE,_step_2.IsDone()); + END_METHOD + + {Test} + METHOD PUBLIC StepBackward_command_should_be_in_done_state_after_succesfull_execution + VAR + _previousOrder : ULINT; + END_VAR + // Arrange + _sequencer.SetSteppingMode(eSteppingMode#StepByStep); + THIS.ExecuteSequence(FALSE,FALSE); + _sequencer.RequestStep(_step_3); + _sequencer.StepIn.Invoke(); + THIS.ExecuteSequence(FALSE,FALSE); + + Assert.Equal(TRUE ,_sequencer.StepBackwardCommand.IsReady()); + Assert.Equal(FALSE,_sequencer.StepBackwardCommand.IsBusy()); + Assert.Equal(FALSE,_sequencer.StepBackwardCommand.IsDone()); + + // Act + _context.Open(); + _sequencer.Open(); + _sequencer.StepBackwardCommand.Invoke(); + _step_1.Execute(_sequencer); + _step_2.Execute(_sequencer); + _step_3.Execute(_sequencer); + + // Assert + Assert.Equal(FALSE,_sequencer.StepBackwardCommand.IsReady()); + Assert.Equal(FALSE,_sequencer.StepBackwardCommand.IsBusy()); + Assert.Equal(TRUE ,_sequencer.StepBackwardCommand.IsDone()); + END_METHOD + + {Test} + METHOD PUBLIC StepBackward_command_should_decrement_Current_order_if_its_value_is_higher_then_one + VAR + _previousOrder : ULINT; + END_VAR + // Arrange + _sequencer.SetSteppingMode(eSteppingMode#StepByStep); + THIS.ExecuteSequence(FALSE,FALSE); + _sequencer.RequestStep(_step_3); + _sequencer.StepIn.Invoke(); + THIS.ExecuteSequence(FALSE,FALSE); + + _previousOrder := _sequencer.CurrentOrder; + + // Act + _context.Open(); + _sequencer.Open(); + _sequencer.StepBackwardCommand.Invoke(); + _step_1.Execute(_sequencer); + _step_2.Execute(_sequencer); + _step_3.Execute(_sequencer); + + // Assert + Assert.Equal(_previousOrder - ULINT#1 ,_sequencer.CurrentOrder); + END_METHOD + + {Test} + METHOD PUBLIC StepBackward_command_should_be_disabled_when_CurrentOrder_is_equal_to_last_step_order + _sequencer.SetSteppingMode(eSteppingMode#StepByStep); + THIS.ExecuteSequence(FALSE,FALSE); + + Assert.Equal(ULINT#1,_sequencer.CurrentOrder); + Assert.Equal(TRUE ,_sequencer.StepBackwardCommand.IsDisabled); + Assert.Equal(FALSE,_sequencer.StepBackwardCommand.IsReady()); + Assert.Equal(FALSE,_sequencer.StepBackwardCommand.IsBusy()); + Assert.Equal(FALSE,_sequencer.StepBackwardCommand.IsDone()); + END_METHOD + END_CLASS END_NAMESPACE From f4943c654f181a5e7779437b6f15d2e179225c81 Mon Sep 17 00:00:00 2001 From: Peter <61538034+PTKu@users.noreply.github.com> Date: Tue, 31 Jan 2023 16:53:24 +0100 Subject: [PATCH 2/3] adds ws --- src/workspace.ix.framework.code-workspace | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 src/workspace.ix.framework.code-workspace diff --git a/src/workspace.ix.framework.code-workspace b/src/workspace.ix.framework.code-workspace new file mode 100644 index 000000000..a7eb14f23 --- /dev/null +++ b/src/workspace.ix.framework.code-workspace @@ -0,0 +1,13 @@ +{ + "folders": [ + { + "name": "integrations", + "path": "integrations\\ctrl" + }, + { + "name": "core", + "path": "core\\ctrl" + } + ], + "settings": {} +} \ No newline at end of file From 6c6424b66bac41afd68db5205f3328db1667db25 Mon Sep 17 00:00:00 2001 From: Peter <61538034+PTKu@users.noreply.github.com> Date: Tue, 31 Jan 2023 17:36:09 +0100 Subject: [PATCH 3/3] changing version postponed due to PR checks --- cake/Program.cs | 48 +++++++++++++++++++++++++----------------------- 1 file changed, 25 insertions(+), 23 deletions(-) diff --git a/cake/Program.cs b/cake/Program.cs index 0c4da0293..00f9d5db5 100644 --- a/cake/Program.cs +++ b/cake/Program.cs @@ -93,32 +93,10 @@ private static void ProvisionTools(BuildContext context) [IsDependentOn(typeof(ProvisionTask))] public sealed class BuildTask : FrostingTask { - - private void UpdateApaxVersion(string file, string version) - { - var sb = new StringBuilder(); - foreach (var line in System.IO.File.ReadLines(file)) - { - var newLine = line; - - if (line.Trim().StartsWith("version")) - { - var semicPosition = line.IndexOf(":"); - var lenght = line.Length - semicPosition; - - newLine = $"{line.Substring(0, semicPosition)} : '{version}'"; - } - sb.AppendLine(newLine); - } - - System.IO.File.WriteAllText(file, sb.ToString()); - } - public override void Run(BuildContext context) { context.Libraries.ToList().ForEach(lib => { - UpdateApaxVersion(context.GetApaxFile(lib), GitVersionInformation.SemVer); context.ApaxInstall(lib); context.ApaxBuild(lib); }); @@ -153,6 +131,26 @@ public override void Run(BuildContext context) [IsDependentOn(typeof(TestsTask))] public sealed class CreateArtifactsTask : FrostingTask { + private void UpdateApaxVersion(string file, string version) + { + var sb = new StringBuilder(); + foreach (var line in System.IO.File.ReadLines(file)) + { + var newLine = line; + + if (line.Trim().StartsWith("version")) + { + var semicPosition = line.IndexOf(":"); + var lenght = line.Length - semicPosition; + + newLine = $"{line.Substring(0, semicPosition)} : '{version}'"; + } + sb.AppendLine(newLine); + } + + System.IO.File.WriteAllText(file, sb.ToString()); + } + public override void Run(BuildContext context) { if (!context.BuildParameters.DoPublish) @@ -161,7 +159,11 @@ public override void Run(BuildContext context) return; } - context.Libraries.ToList().ForEach(lib => context.ApaxPack(lib)); + context.Libraries.ToList().ForEach(lib => + { + UpdateApaxVersion(context.GetApaxFile(lib), GitVersionInformation.SemVer); + context.ApaxPack(lib); + }); PackPackages(context, Path.Combine(context.RootDir, "ix.framework-packable-only.slnf")); }