SPDX-License-Identifier: CC-BY-SA-4.0 OR BSD-2-Clause
copyrights:
- Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de)
enabled-by: true
functional-type: action
links:
- role: interface-function
  uid: ../if/mode
post-conditions:
- name: Status
  states:
  - name: Ok
    test-code: |
      T_rsc_success( ctx->status );
    text: |
      The return status of ${../if/mode:/name} shall be
      ${../../status/if/successful:/name}.
  - name: InvAddr
    test-code: |
      T_rsc( ctx->status, RTEMS_INVALID_ADDRESS );
    text: |
      The return status of ${../if/mode:/name} shall be
      ${../../status/if/invalid-address:/name}.
  - name: NotImplIntLvl
    test-code: |
      T_rsc( ctx->status, RTEMS_NOT_IMPLEMENTED );
    text: |
      The return status of ${../if/mode:/name} shall be
      ${../../status/if/not-implemented:/name}.
  - name: NotImplIntLvlSMP
    test-code: |
      if ( rtems_configuration_get_maximum_processors() > 1 ) {
        T_rsc( ctx->status, RTEMS_NOT_IMPLEMENTED );
      } else {
        T_rsc_success( ctx->status );
      }
    text: |
      Where the system needs inter-processor interrupts, the return status of
      ${../if/mode:/name} shall be ${../../status/if/not-implemented:/name}.

      Where the system does not need inter-processor interrupts, the return
      status of ${../if/mode:/name} shall be
      ${../../status/if/successful:/name}.
  - name: NotImplNoPreempt
    test-code: |
      if ( rtems_configuration_get_maximum_processors() > 1 ) {
        T_rsc( ctx->status, RTEMS_NOT_IMPLEMENTED );
      } else {
        T_rsc_success( ctx->status );
      }
    text: |
      Where the scheduler does not support the no-preempt mode, the return
      status of ${../if/mode:/name} shall be
      ${../../status/if/not-implemented:/name}.

      Where the scheduler does support the no-preempt mode, the return status
      of ${../if/mode:/name} shall be ${../../status/if/successful:/name}.
  test-epilogue: null
  test-prologue: null
- name: Preempt
  states:
  - name: 'Yes'
    test-code: |
      T_eq_u32( ctx->worker_counter_after, ctx->worker_counter_before + 1 );
    text: |
      The calling task shall be preempted by a higher priority ready task
      during the ${../if/mode:/name} call.
  - name: 'No'
    test-code: |
      T_eq_u32( ctx->worker_counter_after, ctx->worker_counter_before );
    text: |
      The calling task shall not be preempted during the ${../if/mode:/name}
      call.
  - name: Maybe
    test-code: |
      if ( rtems_configuration_get_maximum_processors() > 1 ) {
        T_eq_u32( ctx->worker_counter_after, ctx->worker_counter_before );
      } else {
        T_eq_u32( ctx->worker_counter_after, ctx->worker_counter_before + 1 );
      }
    text: |
      Where the scheduler does not support the no-preempt mode, the calling
      task shall not be preempted during the ${../if/mode:/name} call.

      Where the scheduler does support the no-preempt mode, the calling task
      shall be preempted by a higher priority ready task during the
      ${../if/mode:/name} call.
  test-epilogue: null
  test-prologue: null
- name: ASR
  states:
  - name: 'Yes'
    test-code: |
      T_eq_u32( ctx->signal_counter_after, ctx->signal_counter_before + 1 );
    text: |
      The calling task shall process pending signals during the
      ${../if/mode:/name} call.
  - name: 'No'
    test-code: |
      T_eq_u32( ctx->signal_counter_after, ctx->signal_counter_before );
    text: |
      The calling task shall not process signals during the ${../if/mode:/name}
      call.
  - name: Maybe
    test-code: |
      if ( rtems_configuration_get_maximum_processors() > 1 ) {
        T_eq_u32( ctx->signal_counter_after, ctx->signal_counter_before );
      } else {
        T_eq_u32( ctx->signal_counter_after, ctx->signal_counter_before + 1 );
      }
    text: |
      Where the scheduler does not support the no-preempt mode, the calling
      task shall not process signals during the ${../if/mode:/name} call.

      Where the scheduler does support the no-preempt mode, the calling task
      shall process pending signals during the ${../if/mode:/name} call.
  test-epilogue: null
  test-prologue: null
- name: PMVar
  states:
  - name: Set
    test-code: |
      T_eq_ptr( ctx->previous_mode_set, &ctx->previous_mode_set_value );
      T_eq_u32( ctx->previous_mode_set_value, ctx->current_mode );
    text: |
      The value of the object referenced by the ${../if/mode:/params[2]/name}
      parameter shall be set to the task modes of the calling task on entry of
      the call to ${../if/mode:/name}.
  - name: Nop
    test-code: |
      T_eq_u32( ctx->previous_mode_set_value, INVALID_MODE );
    text: |
      Objects referenced by the ${../if/create:/params[2]/name} parameter in
      past calls to ${../if/mode:/name} shall not be accessed by the
      ${../if/mode:/name} call.
  - name: Maybe
    test-code: |
      T_eq_ptr( ctx->previous_mode_set, &ctx->previous_mode_set_value );

      if ( rtems_configuration_get_maximum_processors() > 1 ) {
        T_eq_u32( ctx->previous_mode_set_value, INVALID_MODE );
      } else {
        T_eq_u32( ctx->previous_mode_set_value, ctx->current_mode );
      }
    text: |
      Where the scheduler does not support the no-preempt mode, objects
      referenced by the ${../if/create:/params[2]/name} parameter in past calls
      to ${../if/mode:/name} shall not be accessed by the ${../if/mode:/name}
      call.

      Where the scheduler does support the no-preempt mode, the value of the
      object referenced by the ${../if/mode:/params[2]/name} parameter shall be
      set to the task modes of the calling task on entry of the call to
      ${../if/mode:/name}.
  test-epilogue: null
  test-prologue: null
- name: Mode
  states:
  - name: Set
    test-code: |
      CheckMode( ctx, ctx->current_mode, ctx->mode_mask, ctx->mode_set );
    text: |
      The task modes of the calling task indicated by the
      ${../if/mode:/params[1]/name} parameter shall be set to the corrsponding
      modes specified by the ${../if/mode:/params[0]/name} parameter.
  - name: Nop
    test-code: |
      CheckMode( ctx, ctx->current_mode, 0, 0 );
    text: |
      The task modes of the calling task shall not be modified by the
      ${../if/mode:/name} call.
  - name: Maybe
    test-code: |
      if ( rtems_configuration_get_maximum_processors() > 1 ) {
        CheckMode( ctx, ctx->current_mode, 0, 0 );
      } else {
        CheckMode( ctx, ctx->current_mode, ctx->mode_mask, ctx->mode_set );
      }
    text: |
      Where the scheduler does not support the no-preempt mode, the task modes
      of the calling task shall not be modified by the ${../if/mode:/name}
      call.

      Where the scheduler does support the no-preempt mode, the task modes of
      the calling task indicated by the ${../if/mode:/params[1]/name} parameter
      shall be set to the corrsponding modes specified by the
      ${../if/mode:/params[0]/name} parameter.
  test-epilogue: null
  test-prologue: null
pre-conditions:
- name: PrevMode
  states:
  - name: Valid
    test-code: |
      ctx->previous_mode_set = &ctx->previous_mode_set_value;
    text: |
      While the ${../if/mode:/params[2]/name} parameter references an object of
      type ${../../mode/if/mode:/name}.
  - name: 'Null'
    test-code: |
      ctx->previous_mode_set = NULL;
    text: |
      While the ${../if/mode:/params[2]/name} parameter is ${/c/if/null:/name}.
  test-epilogue: null
  test-prologue: null
- name: PreemptCur
  states:
  - name: 'Yes'
    test-code: |
      ctx->current_mode |= RTEMS_PREEMPT;
    text: |
      While the calling task has preemption enabled.
  - name: 'No'
    test-code: |
      if ( rtems_configuration_get_maximum_processors() > 1 ) {
        ctx->current_mode |= RTEMS_PREEMPT;
      } else {
        ctx->current_mode |= RTEMS_NO_PREEMPT;
      }
    text: |
      Where the scheduler does not support the no-preempt mode, while the
      calling task has preemption enabled.

      Where the scheduler does support the no-preempt mode, while the calling
      task has preemption disabled.
  test-epilogue: null
  test-prologue: null
- name: TimesliceCur
  states:
  - name: 'Yes'
    test-code: |
      ctx->current_mode |= RTEMS_TIMESLICE;
    text: |
      While the calling task has timeslicing enabled.
  - name: 'No'
    test-code: |
      ctx->current_mode |= RTEMS_NO_TIMESLICE;
    text: |
      While the calling task has timeslicing disabled.
  test-epilogue: null
  test-prologue: null
- name: ASRCur
  states:
  - name: 'Yes'
    test-code: |
      ctx->current_mode |= RTEMS_ASR;
    text: |
      While the calling task has ASR processing enabled.
  - name: 'No'
    test-code: |
      ctx->current_mode |= RTEMS_NO_ASR;
    text: |
      While the calling task has ASR processing disabled.
  test-epilogue: null
  test-prologue: null
- name: IntLvlCur
  states:
  - name: Zero
    test-code: |
      ctx->current_mode |= RTEMS_INTERRUPT_LEVEL( 0 );
    text: |
      While the calling task executes with an interrupt level of zero.
  - name: Positive
    test-code: |
      if ( rtems_configuration_get_maximum_processors() > 1 ) {
        ctx->current_mode |= RTEMS_INTERRUPT_LEVEL( 0 );
      } else {
        ctx->current_mode |= RTEMS_INTERRUPT_LEVEL( 1 );
      }
    text: |
      Where the system needs inter-processor interrupts, while the calling task
      executes with an interrupt level of zero.

      Where the system does not need inter-processor interrupts, while the
      calling task executes with an an interrupt level greater than zero and
      less than or equal to ${/score/cpu/if/modes-interrupt-mask:/name}.
  test-epilogue: null
  test-prologue: null
- name: Preempt
  states:
  - name: 'Yes'
    test-code: |
      ctx->mode_set |= RTEMS_PREEMPT;
    text: |
      While the ${../if/mode:/params[0]/name} parameter specifies that
      preemption is enabled.
  - name: 'No'
    test-code: |
      ctx->mode_set |= RTEMS_NO_PREEMPT;
    text: |
      While the ${../if/mode:/params[0]/name} parameter specifies that
      preemption is disabled.
  test-epilogue: null
  test-prologue: null
- name: Timeslice
  states:
  - name: 'Yes'
    test-code: |
      ctx->mode_set |= RTEMS_TIMESLICE;
    text: |
      While the ${../if/mode:/params[0]/name} parameter specifies that
      timeslicing is enabled.
  - name: 'No'
    test-code: |
      ctx->mode_set |= RTEMS_NO_TIMESLICE;
    text: |
      While the ${../if/mode:/params[0]/name} parameter specifies that
      timeslicing is disabled.
  test-epilogue: null
  test-prologue: null
- name: ASR
  states:
  - name: 'Yes'
    test-code: |
      ctx->mode_set |= RTEMS_ASR;
    text: |
      While the ${../if/mode:/params[0]/name} parameter specifies that
      ASR processing is enabled.
  - name: 'No'
    test-code: |
      ctx->mode_set |= RTEMS_NO_ASR;
    text: |
      While the ${../if/mode:/params[0]/name} parameter specifies that
      ASR processing is disabled.
  test-epilogue: null
  test-prologue: null
- name: IntLvl
  states:
  - name: Zero
    test-code: |
      ctx->mode_set |= RTEMS_INTERRUPT_LEVEL( 0 );
    text: |
      While the ${../if/mode:/params[0]/name} parameter specifies an interrupt
      level of zero.
  - name: Positive
    test-code: |
      ctx->mode_set |= RTEMS_INTERRUPT_LEVEL( 1 );
    text: |
      While the ${../if/mode:/params[0]/name} parameter specifies an interrupt
      level greater than zero and less than or equal to
      ${/score/cpu/if/modes-interrupt-mask:/name}.
  test-epilogue: null
  test-prologue: null
- name: PreemptMsk
  states:
  - name: 'Yes'
    test-code: |
      ctx->mode_mask |= RTEMS_PREEMPT_MASK;
    text: |
      While the ${../if/mode:/params[1]/name} parameter specifies that the
      preemption mode shall be set.
  - name: 'No'
    test-code: |
      /* This is the default mode mask */
    text: |
      While the ${../if/mode:/params[1]/name} parameter specifies that the
      preemption mode shall not be set.
  test-epilogue: null
  test-prologue: null
- name: TimesliceMsk
  states:
  - name: 'Yes'
    test-code: |
      ctx->mode_mask |= RTEMS_TIMESLICE_MASK;
    text: |
      While the ${../if/mode:/params[1]/name} parameter specifies that the
      timeslicing mode shall be set.
  - name: 'No'
    test-code: |
      /* This is the default mode mask */
    text: |
      While the ${../if/mode:/params[1]/name} parameter specifies that the
      timeslicing mode shall not be set.
  test-epilogue: null
  test-prologue: null
- name: ASRMsk
  states:
  - name: 'Yes'
    test-code: |
      ctx->mode_mask |= RTEMS_ASR_MASK;
    text: |
      While the ${../if/mode:/params[1]/name} parameter specifies that the
      ASR processing mode shall be set.
  - name: 'No'
    test-code: |
      /* This is the default mode mask */
    text: |
      While the ${../if/mode:/params[1]/name} parameter specifies that the
      ASR processing mode shall not be set.
  test-epilogue: null
  test-prologue: null
- name: IntLvlMsk
  states:
  - name: 'Yes'
    test-code: |
      ctx->mode_mask |= RTEMS_INTERRUPT_MASK;
    text: |
      While the ${../if/mode:/params[1]/name} parameter specifies that the
      interrupt level shall be set.
  - name: 'No'
    test-code: |
      /* This is the default mode mask */
    text: |
      While the ${../if/mode:/params[1]/name} parameter specifies that the
      interrupt level shall not be set.
  test-epilogue: null
  test-prologue: null
rationale: null
references: []
requirement-type: functional
skip-reasons:
  RobustThreadDispatching: |
    Where the system enabled robust thread dispatching, the interrupt level
    mode of a task shall be exactly zero.
test-action: |
  rtems_status_code sc;
  rtems_mode        mode;

  sc = rtems_task_mode( ctx->current_mode, RTEMS_ALL_MODE_MASKS, &mode );
  T_rsc_success( sc );

  SendEvents( ctx->worker_id, EVENT_MAKE_READY );

  sc = rtems_signal_catch( SignalHandler, ctx->current_mode | RTEMS_NO_ASR );
  T_rsc_success( sc );

  sc = rtems_signal_send( RTEMS_SELF, 0xdeadbeef );
  T_rsc_success( sc );

  ctx->worker_counter_before = ctx->worker_counter;
  ctx->signal_counter_before = ctx->signal_counter;
  ctx->status = rtems_task_mode(
    ctx->mode_set,
    ctx->mode_mask,
    ctx->previous_mode_set
  );
  ctx->worker_counter_after = ctx->worker_counter;
  ctx->signal_counter_after = ctx->signal_counter;
test-brief: null
test-cleanup: |
  rtems_status_code sc;
  rtems_mode        mode;

  sc = rtems_task_mode( RTEMS_DEFAULT_MODES, RTEMS_ALL_MODE_MASKS, &mode );
  T_rsc_success( sc );

  sc = rtems_task_wake_after( RTEMS_YIELD_PROCESSOR );
  T_rsc_success( sc );

  sc = rtems_signal_catch( NULL, RTEMS_DEFAULT_MODES );
  T_rsc_success( sc );
test-context:
- brief: |
    This member contains the object identifier of the worker task.
  description: null
  member: |
    rtems_id worker_id
- brief: null
    If this member is contains the initial mode of the runner.
  description: null
  member: |
    rtems_mode runner_mode
- brief: |
    This member provides a value for the previous mode set.
  description: null
  member: |
    rtems_mode previous_mode_set_value
- brief: |
    This member specifies the task mode in which rtems_task_mode() is called.
  description: null
  member: |
    rtems_mode current_mode
- brief: |
    This member counts worker activity.
  description: null
  member: |
    uint32_t worker_counter
- brief: |
    This member contains worker counter before the rtems_task_mode() call.
  description: null
  member: |
    uint32_t worker_counter_before
- brief: |
    This member contains worker counter after the rtems_task_mode() call.
  description: null
  member: |
    uint32_t worker_counter_after
- brief: |
    This member counts signal handler activity.
  description: null
  member: |
    uint32_t signal_counter
- brief: |
    This member contains signal counter before the rtems_task_mode() call.
  description: null
  member: |
    uint32_t signal_counter_before
- brief: |
    This member contains signal counter after the rtems_task_mode() call.
  description: null
  member: |
    uint32_t signal_counter_after
- brief: |
    This member specifies the ${../if/mode:/params[0]/name} parameter for
    rtems_task_mode().
  description: null
  member: |
    rtems_mode mode_set
- brief: |
    This member specifies the mode mask ${../if/mode:/params[1]/name} parameter
    for rtems_task_mode() for the action.
  description: null
  member: |
    rtems_mode mode_mask
- brief: |
    This member specifies the previous mode set ${../if/mode:/params[2]/name}
    parameter for rtems_task_mode().
  description: null
  member: |
    rtems_mode *previous_mode_set
- brief: |
    This member contains the return status of the rtems_task_mode() call.
  description: null
  member: |
    rtems_status_code status
test-context-support: null
test-description: null
test-header: null
test-includes:
- rtems.h
- string.h
test-local-includes:
- tx-support.h
test-prepare: |
  ctx->current_mode = RTEMS_DEFAULT_MODES;
  ctx->mode_set = RTEMS_DEFAULT_MODES;
  ctx->mode_mask = RTEMS_CURRENT_MODE;
  ctx->previous_mode_set_value = INVALID_MODE;
test-setup:
  brief: null
  code: |
    rtems_status_code sc;

    memset( ctx, 0, sizeof( *ctx ) );

    sc = rtems_task_mode(
      RTEMS_DEFAULT_MODES,
      RTEMS_CURRENT_MODE,
      &ctx->runner_mode
    );
    T_rsc_success( sc );

    SetSelfPriority( PRIO_NORMAL );
    ctx->worker_id = CreateTask( "WORK", PRIO_HIGH );
    StartTask( ctx->worker_id, Worker, ctx );
  description: null
test-stop: null
test-support: |
  #define INVALID_MODE 0xffffffff

  #define EVENT_MAKE_READY RTEMS_EVENT_0

  #define EVENT_TIMESLICE RTEMS_EVENT_1

  typedef RtemsTaskReqMode_Context Context;

  static void Worker( rtems_task_argument arg )
  {
    Context *ctx;

    ctx = (Context *) arg;

    while ( true ) {
      rtems_event_set events;

      events = ReceiveAnyEvents();

      if ( ( events & EVENT_TIMESLICE ) != 0 ) {
        SetSelfPriority( PRIO_NORMAL );
        SetSelfPriority( PRIO_HIGH );
      }

      ++ctx->worker_counter;
    }
  }

  static void SignalHandler( rtems_signal_set signal_set )
  {
    Context *ctx;

    ctx = T_fixture_context();
    ++ctx->signal_counter;
    T_eq_u32( signal_set, 0xdeadbeef );
  }

  static void ExhaustTimeslice( void )
  {
    uint32_t ticks;

    for (
      ticks = 0;
      ticks < rtems_configuration_get_ticks_per_timeslice();
      ++ticks
    ) {
      ClockTick();
    }
  }

  static void CheckMode(
    Context   *ctx,
    rtems_mode mode,
    rtems_mode mask,
    rtems_mode set
  )
  {
    rtems_status_code sc;
    uint32_t          counter;

    mode &= ~mask;
    mode |= set & mask;

    counter = ctx->worker_counter;
    SendEvents( ctx->worker_id, EVENT_MAKE_READY );

    if ( ( mode & RTEMS_PREEMPT_MASK ) == RTEMS_PREEMPT ) {
      T_eq_u32( ctx->worker_counter, counter + 1 );
    } else {
      T_eq_u32( ctx->worker_counter, counter );
    }

    counter = ctx->worker_counter;
    SendEvents( ctx->worker_id, EVENT_TIMESLICE );
    ExhaustTimeslice();

    if ( ( mode & RTEMS_PREEMPT_MASK ) == RTEMS_PREEMPT ) {
      if ( ( mode & RTEMS_TIMESLICE_MASK ) == RTEMS_TIMESLICE ) {
        T_eq_u32( ctx->worker_counter, counter + 1 );
      } else {
        T_eq_u32( ctx->worker_counter, counter );
      }
    } else {
      T_eq_u32( ctx->worker_counter, counter );
    }

    counter = ctx->signal_counter;
    sc = rtems_signal_send( RTEMS_SELF, 0xdeadbeef );
    T_rsc_success( sc );

    if ( ( mode & RTEMS_ASR_MASK ) == RTEMS_ASR ) {
      T_eq_u32( ctx->signal_counter, counter + 1 );
    } else {
      T_eq_u32( ctx->signal_counter, counter );
    }

    T_eq_u32( mode & RTEMS_INTERRUPT_MASK, _ISR_Get_level() );
  }
test-target: testsuites/validation/tc-task-mode.c
test-teardown:
  brief: null
  code: |
    DeleteTask( ctx->worker_id );
    RestoreRunnerMode();
    RestoreRunnerPriority();
  description: null
text: ${.:text-template}
transition-map:
- enabled-by: true
  post-conditions:
    Status:
    - if:
        pre-conditions:
          PrevMode: 'Null'
      then: InvAddr
    - else: Ok
    Preempt:
    - if:
        and:
        - post-conditions:
            Status: Ok
        - pre-conditions:
            PreemptCur: 'No'
            Preempt: 'Yes'
            PreemptMsk: 'Yes'
      then: 'Yes'
    - else: 'No'
    ASR:
    - if:
        and:
        - post-conditions:
            Status: Ok
        - pre-conditions:
            ASRCur: 'No'
            ASR: 'Yes'
            ASRMsk: 'Yes'
      then: 'Yes'
    - else: 'No'
    PMVar:
    - if:
        pre-conditions:
          PrevMode: 'Null'
      then: Nop
    - else: Set
    Mode:
    - if:
        pre-conditions:
          PrevMode: 'Null'
      then: Nop
    - else: Set
  pre-conditions:
    PreemptCur: all
    TimesliceCur: all
    ASRCur: all
    IntLvlCur: all
    Preempt: all
    Timeslice: all
    ASR: all
    IntLvl: all
    PreemptMsk: all
    TimesliceMsk: all
    ASRMsk: all
    IntLvlMsk: all
    PrevMode: all
- enabled-by: CPU_ENABLE_ROBUST_THREAD_DISPATCH
  post-conditions:
    Status: NotImplIntLvl
    Preempt: 'No'
    ASR: 'No'
    PMVar: Nop
    Mode: Nop
  pre-conditions:
    PreemptCur: all
    TimesliceCur: all
    ASRCur: all
    IntLvlCur:
    - Zero
    Preempt: all
    Timeslice: all
    ASR: all
    IntLvl:
    - Positive
    PreemptMsk: all
    TimesliceMsk: all
    ASRMsk: all
    IntLvlMsk:
    - 'Yes'
    PrevMode:
    - Valid
- enabled-by: CPU_ENABLE_ROBUST_THREAD_DISPATCH
  post-conditions: RobustThreadDispatching
  pre-conditions:
    PreemptCur: all
    TimesliceCur: all
    ASRCur: all
    IntLvlCur:
    - Positive
    Preempt: all
    Timeslice: all
    ASR: all
    IntLvl: all
    PreemptMsk: all
    TimesliceMsk: all
    ASRMsk: all
    IntLvlMsk: all
    PrevMode: all
- enabled-by: RTEMS_SMP
  post-conditions:
    Status:
    - if:
        pre-conditions:
          Preempt: 'No'
          PreemptMsk: 'Yes'
      then: NotImplNoPreempt
    - if:
        pre-conditions:
          IntLvl: Positive
          IntLvlMsk: 'Yes'
      then: NotImplIntLvlSMP
    - else: Ok
    Preempt:
    - if:
        pre-conditions:
          PreemptCur: 'No'
          Preempt: 'Yes'
          PreemptMsk: 'Yes'
      then: Maybe
    - else: 'No'
    ASR:
    - if:
        and:
          - pre-conditions:
              ASRCur: 'No'
              ASR: 'Yes'
              ASRMsk: 'Yes'
          - or:
            - pre-conditions:
                Preempt: 'No'
                PreemptMsk: 'Yes'
            - pre-conditions:
                IntLvl: Positive
                IntLvlMsk: 'Yes'
      then: Maybe
    - if:
        and:
          - pre-conditions:
              ASRCur: 'No'
              ASR: 'Yes'
              ASRMsk: 'Yes'
          - or:
            - pre-conditions:
                PreemptMsk: 'No'
                IntLvlMsk: 'No'
            - pre-conditions:
                Preempt: 'Yes'
                IntLvlMsk: 'No'
            - pre-conditions:
                PreemptMsk: 'No'
                IntLvl: Zero
            - pre-conditions:
                Preempt: 'Yes'
                IntLvl: Zero
      then: 'Yes'
    - else: 'No'
    PMVar:
    - if:
      - pre-conditions:
          Preempt: 'No'
          PreemptMsk: 'Yes'
      - pre-conditions:
          IntLvl: Positive
          IntLvlMsk: 'Yes'
      then: Maybe
    - else: Set
    Mode:
    - if:
      - pre-conditions:
          Preempt: 'No'
          PreemptMsk: 'Yes'
      - pre-conditions:
          IntLvl: Positive
          IntLvlMsk: 'Yes'
      then: Maybe
    - else: Set
  pre-conditions:
    PreemptCur: all
    TimesliceCur: all
    ASRCur: all
    IntLvlCur: all
    Preempt: all
    Timeslice: all
    ASR: all
    IntLvl: all
    PreemptMsk: all
    TimesliceMsk: all
    ASRMsk: all
    IntLvlMsk: all
    PrevMode:
    - Valid
type: requirement