anchor.diff:                  lane_runs = [
                       ResumedLaneRunBaseTestSpec#atm_lane_run_execution_test_spec{
                           resume_lane = #atm_step_mock_spec{
  -                            before_step_exp_state_diff = fun(#atm_mock_call_ctx{workflow_execution_exp_state = ExpState0}) ->
  -                                ExpState1 = atm_workflow_execution_exp_state_builder:expect_lane_run_resuming({1, 1}, ExpState0),
  -                                {true, atm_workflow_execution_exp_state_builder:expect_workflow_execution_resuming(ExpState1)}
  -                            end,
  -                            after_step_exp_state_diff = fun(#atm_mock_call_ctx{workflow_execution_exp_state = ExpState0}) ->
  -                                ExpState1 = atm_workflow_execution_exp_state_builder:expect_all_tasks_active({1, 1}, ExpState0),
  -                                ExpState2 = atm_workflow_execution_exp_state_builder:expect_lane_run_active({1, 1}, ExpState1),
  -                                {true, atm_workflow_execution_exp_state_builder:expect_workflow_execution_active(ExpState2)}
  -                            end
  +                            before_step_exp_state_diff = [
  +                                {lane_run, {1, 1}, resuming},
  +                                workflow_resuming
  +                            ],
  +                            after_step_exp_state_diff = [
  +                                {all_tasks, {1, 1}, active},
  +                                {lane_run, {1, 1}, active},
  +                                workflow_active
  +                            ]
                           }
                       },
  -                    build_failed_atm_lane1_run_execution_test_spec({1, 2}, {0, 0, 3}, {0, 3, 3}, [2, 4, 6], false),
  -                    build_failed_atm_lane1_run_execution_test_spec({1, 3}, {0, 0, 3}, {0, 3, 3}, [2, 4, 6], true),
  +                    build_lane_run_execution_test_spec_with_even_numbers({1, 2}, {0, 0, 3}, {0, 3, 3}, [2, 4, 6], false),
  +                    build_lane_run_execution_test_spec_with_even_numbers({1, 3}, {0, 0, 3}, {0, 3, 3}, [2, 4, 6], true),
   
                       #atm_lane_run_execution_test_spec{
                           selector = {2, 3},
  
positive.code:         }
      }
  ).
  -define(ATM_WORKFLOW_SCHEMA_DRAFT, ?ATM_WORKFLOW_SCHEMA_DRAFT(
      ?FUNCTION_NAME, [?RAND_INT(100)], ?ECHO_DOCKER_IMAGE_ID
  )).
  
  
  %%%===================================================================
  
negative.code: 
  
  %% @private
  random_odd_number() ->
      case ?RAND_INT(100) of
          Odd when Odd rem 2 == 1 -> Odd;
          Even -> Even + 1
      end.
  
  
  %% @private
  get_suspend_hook(paused) -> fun atm_workflow_execution_test_utils:pause_workflow_execution/1;
  get_suspend_hook(interrupted) -> fun atm_workflow_execution_test_utils:interrupt_workflow_execution/1.
  
  
  %% @private
  build_workflow_suspended_expectation(paused) -> workflow_paused;
  build_workflow_suspended_expectation(interrupted) -> workflow_interrupted.
  
  
  %% @private
  build_handle_task1_execution_stopped_exp_state_diff(Expectations) ->
      fun(#atm_mock_call_ctx{
          workflow_execution_exp_state = ExpState0,
          call_args = [_AtmWorkflowExecutionId, _AtmWorkflowExecutionEnv, AtmTaskExecutionId]
      }) ->
          case atm_workflow_execution_exp_state_builder:get_task_schema_id(AtmTaskExecutionId, ExpState0) of
              <<"task1">> -> {true, atm_workflow_execution_exp_state_builder:expect(ExpState0, Expectations)};
              <<"task2">> -> false
          end
      end.
  
  
  %% @private
  build_lane_run_execution_test_spec_with_even_numbers(
      AtmLaneRunSelector, ExpTask1FinalStats, ExpTask2FinalStats, ExpExceptionStoreContent, IsLastExpLaneRun
  ) ->
      #atm_lane_run_execution_test_spec{
          selector = AtmLaneRunSelector,
          process_task_result_for_item = 'build mock spec for process_task_result_for_item with even numbers step'(),
  
          handle_task_execution_stopped = #atm_step_mock_spec{
              before_step_hook = fun(AtmMockCallCtx) ->
                  assert_lane1_task_execution_stopped_stats(ExpTask1FinalStats, ExpTask2FinalStats, AtmMockCallCtx)
              end,
              after_step_exp_state_diff = fun(#atm_mock_call_ctx{
                  workflow_execution_exp_state = ExpState,
                  call_args = [_AtmWorkflowExecutionId, _AtmWorkflowExecutionEnv, AtmTaskExecutionId]
              }) ->
                  StoppedStatus = case atm_workflow_execution_exp_state_builder:get_task_schema_id(
                      AtmTaskExecutionId, ExpState
                  ) of
                      <<"task1">> -> finished;
                      <<"task2">> -> failed
                  end,
                  Expectations = build_expectations_for_lane1_task_transitioned_to(AtmTaskExecutionId, StoppedStatus),
                  {true, atm_workflow_execution_exp_state_builder:expect(ExpState, Expectations)}
              end
          },
  
          handle_lane_execution_stopped = #atm_step_mock_spec{
              after_step_hook = fun(AtmMockCallCtx) ->
                  assert_exception_store_content(ExpExceptionStoreContent, AtmLaneRunSelector, AtmMockCallCtx)
              end,
              after_step_exp_state_diff = fun(#atm_mock_call_ctx{workflow_execution_exp_state = ExpState0}) ->
                  Expectations = [{lane_run, AtmLaneRunSelector, failed}, case IsLastExpLaneRun of
                      true -> workflow_stopping;
                      false -> {lane_run, AtmLaneRunSelector, automatic_retry_scheduled}
                  end],
                  {true, atm_workflow_execution_exp_state_builder:expect(ExpState0, Expectations)}
              end
          }
      }.
  
  
  %% @private
  'build mock spec for process_task_result_for_item with even numbers step'() ->
      #atm_step_mock_spec{
          after_step_exp_state_diff = fun(#atm_mock_call_ctx{
              workflow_execution_exp_state = ExpState0,
  