source: rtems-central/spec/score/interr/val/terminate.yml @ f048c15

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
links: []
test-actions:
- action-brief: |
    Create five dynamic extensions.  Call the system termination procedure.
    Delete three dynamic extension during the fatal extension invocation.
    Delete the two remaining dynamic extensions.
  action-code: |
    rtems_status_code      sc;
    rtems_extensions_table table;
    bool                   shutdown_ok;

    #if defined(RTEMS_SMP)
    shutdown_ok =
      ( _Per_CPU_Get_state( _Per_CPU_Get_snapshot() ) == PER_CPU_STATE_UP );
    #else
    shutdown_ok = true;
    #endif

    memset( &table, 0, sizeof( table ) );

    table.fatal = FatalExtension2;
    sc = rtems_extension_create(
      rtems_build_name( ' ', ' ', ' ', '2' ),
      &table,
      &extension_ids[ 2 ]
    );
    T_step_rsc_success( ${step}, sc );

    table.fatal = FatalExtension3;
    sc = rtems_extension_create(
      rtems_build_name( ' ', ' ', ' ', '3' ),
      &table,
      &extension_ids[ 3 ]
    );
    T_step_rsc_success( ${step}, sc );

    table.fatal = FatalExtension4;
    sc = rtems_extension_create(
      rtems_build_name( ' ', ' ', ' ', '4' ),
      &table,
      &extension_ids[ 4 ]
    );
    T_step_rsc_success( ${step}, sc );

    table.fatal = FatalExtension5;
    sc = rtems_extension_create(
      rtems_build_name( ' ', ' ', ' ', '5' ),
      &table,
      &extension_ids[ 5 ]
    );
    T_step_rsc_success( ${step}, sc );

    table.fatal = FatalExtension6;
    sc = rtems_extension_create(
      rtems_build_name( ' ', ' ', ' ', '6' ),
      &table,
      &extension_ids[ 6 ]
    );
    T_step_rsc_success( ${step}, sc );

    test_case_active = true;

    if ( setjmp( before_terminate ) == 0 ) {
      _Terminate( RTEMS_FATAL_SOURCE_APPLICATION, 123456 );
    }

    test_case_active = false;
  checks:
  - brief: |
      Where the system was built with SMP support enabled, check that a
      shutdown request was issued.
    code: |
      #if defined(RTEMS_SMP)
      shutdown_ok = ( shutdown_ok && _ISR_Get_level() != 0 &&
        _Per_CPU_Get_state( _Per_CPU_Get() ) == PER_CPU_STATE_SHUTDOWN );
      _ISR_Set_level( 0 );
      #endif
      T_step_true( ${step}, shutdown_ok );
    links:
    - role: validation
      uid: ../req/terminate-shutdown
  - brief: |
      Delete the dynamic extension sets.
    code: |
      sc = rtems_extension_delete( extension_ids[ 2 ] );
      T_step_rsc_success( ${step}, sc );

      sc = rtems_extension_delete( extension_ids[ 6 ] );
      T_step_rsc_success( ${step}, sc );
    links: []
  - brief: |
      Check that the fatal extensions were invoked with the expected source.
    code: |
      T_step_eq_int(
        ${step},
        info[ 0 ].source,
        RTEMS_FATAL_SOURCE_APPLICATION
      );
      T_step_eq_int(
        ${step},
        info[ 1 ].source,
        RTEMS_FATAL_SOURCE_APPLICATION
      );
      T_step_eq_int(
        ${step},
        info[ 2 ].source,
        RTEMS_FATAL_SOURCE_APPLICATION
      );
      T_step_eq_int(
        ${step},
        info[ 4 ].source,
        RTEMS_FATAL_SOURCE_APPLICATION
      );
      T_step_eq_int(
        ${step},
        info[ 5 ].source,
        RTEMS_FATAL_SOURCE_APPLICATION
      );
      T_step_eq_int(
        ${step},
        info[ 6 ].source,
        RTEMS_FATAL_SOURCE_APPLICATION
      );
    links:
    - role: validation
      uid: ../req/terminate-userext
  - brief: |
      Check that the fatal extensions were invoked with the expected always set
      to false argument.
    code: |
      T_step_false( ${step}, info[ 0 ].always_set_to_false );
      T_step_false( ${step}, info[ 1 ].always_set_to_false );
      T_step_false( ${step}, info[ 2 ].always_set_to_false );
      T_step_false( ${step}, info[ 4 ].always_set_to_false );
      T_step_false( ${step}, info[ 5 ].always_set_to_false );
      T_step_false( ${step}, info[ 6 ].always_set_to_false );
    links:
    - role: validation
      uid: ../req/terminate-userext
  - brief: |
      Check that the fatal extensions were invoked with the expected code.
    code: |
      T_step_eq_ulong( ${step}, info[ 0 ].code, 123456 );
      T_step_eq_ulong( ${step}, info[ 1 ].code, 123456 );
      T_step_eq_ulong( ${step}, info[ 2 ].code, 123456 );
      T_step_eq_ulong( ${step}, info[ 4 ].code, 123456 );
      T_step_eq_ulong( ${step}, info[ 5 ].code, 123456 );
      T_step_eq_ulong( ${step}, info[ 6 ].code, 123456 );
    links:
    - role: validation
      uid: ../req/terminate-userext
  - brief: |
      Check that the fatal extensions were invoked in forward order.
    code: |
      T_step_eq_uint( ${step}, info[ 0 ].counter, 1 );
      T_step_eq_uint( ${step}, info[ 1 ].counter, 2 );
      T_step_eq_uint( ${step}, info[ 2 ].counter, 3 );
      T_step_eq_uint( ${step}, info[ 4 ].counter, 4 );
      T_step_eq_uint( ${step}, info[ 5 ].counter, 5 );
      T_step_eq_uint( ${step}, info[ 6 ].counter, 6 );
    links:
    - role: validation
      uid: /rtems/userext/req/fatal-order
  - brief: |
      Check that the fatal extension in the deleted extension set was not
      invoked.
    code: |
      T_step_eq_int( ${step}, info[ 3 ].source, 0 );
      T_step_false( ${step}, info[ 3 ].always_set_to_false );
      T_step_eq_ulong( ${step}, info[ 3 ].code, 0 );
      T_step_eq_uint( ${step}, info[ 3 ].counter, 0 );
    links:
    - role: validation
      uid: /rtems/userext/req/fatal-iterate-remove
  - brief: |
      Check that the system state is terminated.
    code: |
      T_step_eq_int( ${step}, _System_state_Get(), SYSTEM_STATE_TERMINATED );
    links:
    - role: validation
      uid: ../req/terminate-state
  - brief: |
      Check that the system was halted with the expected fatal source.
    code: |
      T_step_eq_int( ${step}, halt_source, RTEMS_FATAL_SOURCE_APPLICATION );
    links:
    - role: validation
      uid: ../req/terminate-halt
    - role: validation
      uid: ../req/terminate-shutdown-halt
  - brief: |
      Check that the system was halted with the expected fatal code.
    code: |
      T_step_eq_ulong( ${step}, halt_code, 123456 );
    links:
    - role: validation
      uid: ../req/terminate-halt
    - role: validation
      uid: ../req/terminate-shutdown-halt
  - brief: |
      Check that the system was finally halted.
    code: |
      T_step_eq_uint( ${step}, counter, 7 );
    links:
    - role: validation
      uid: ../req/terminate-halt
    - role: validation
      uid: ../req/terminate-shutdown-halt
  links:
  - role: validation
    uid: ../req/terminate
test-brief: |
  Tests system termination procedure.
test-context: []
test-context-support: null
test-description: null
test-header: null
test-includes:
- bsp.h
- rtems/bspIo.h
- rtems/test-info.h
- rtems/score/atomic.h
- rtems/score/io.h
- rtems/score/percpu.h
- rtems/score/sysstate.h
- setjmp.h
- string.h
test-local-includes:
- tc-userext.h
test-setup: null
test-stop: null
test-support: |
  typedef struct {
    unsigned int       counter;
    rtems_fatal_source source;
    bool               always_set_to_false;
    rtems_fatal_code   code;
  } FatalInfo;

  static Atomic_Uint counter;

  static FatalInfo info[ 7 ];

  static bool test_case_active;

  static const rtems_extensions_table bsp = BSP_INITIAL_EXTENSION;

  static jmp_buf before_terminate;

  static unsigned int halt_counter;

  static rtems_fatal_source halt_source;

  static rtems_fatal_code halt_code;

  static rtems_id extension_ids[ 7 ];

  static unsigned int GetCounter( void )
  {
    return _Atomic_Fetch_add_uint( &counter, 1, ATOMIC_ORDER_RELAXED ) + 1;
  }

  void __real__CPU_Fatal_halt( uint32_t source, CPU_Uint32ptr code );

  void __wrap__CPU_Fatal_halt( uint32_t source, CPU_Uint32ptr code );

  void __wrap__CPU_Fatal_halt( uint32_t source, CPU_Uint32ptr code )
  {
    if ( test_case_active ) {
      halt_counter = GetCounter();
      halt_source = source;
      halt_code = code;
      longjmp( before_terminate, 1 );
    } else {
  #if defined(RTEMS_GCOV_COVERAGE)
      rtems_test_gcov_dump_info();
  #endif
      __real__CPU_Fatal_halt( source, code );
    }
  }

  static void FatalExtension(
    rtems_fatal_source source,
    bool               always_set_to_false,
    rtems_fatal_code   code,
    size_t             index
  )
  {
    if ( test_case_active ) {
      info[ index ].counter = GetCounter();
      info[ index ].source = source;
      info[ index ].always_set_to_false = always_set_to_false;
      info[ index ].code = code;
    } else {
      ( *bsp.fatal )( source, always_set_to_false, code );
    }
  }

  void FatalExtension0(
    rtems_fatal_source source,
    bool               always_set_to_false,
    rtems_fatal_code   code
  )
  {
    FatalExtension( source, always_set_to_false, code, 0 );
  }

  void FatalExtension1(
    rtems_fatal_source source,
    bool               always_set_to_false,
    rtems_fatal_code   code
  )
  {
    FatalExtension( source, always_set_to_false, code, 1 );
  }

  static void FatalExtension2(
    rtems_fatal_source source,
    bool               always_set_to_false,
    rtems_fatal_code   code
  )
  {
    rtems_status_code sc;

    FatalExtension( source, always_set_to_false, code, 2 );

    sc = rtems_extension_delete( extension_ids[ 3 ] );
    T_quiet_rsc_success( sc );
  }

  static void FatalExtension3(
    rtems_fatal_source source,
    bool               always_set_to_false,
    rtems_fatal_code   code
  )
  {
    FatalExtension( source, always_set_to_false, code, 3 );
  }

  static void FatalExtension4(
    rtems_fatal_source source,
    bool               always_set_to_false,
    rtems_fatal_code   code
  )
  {
    FatalExtension( source, always_set_to_false, code, 4 );
  }

  static void FatalExtension5(
    rtems_fatal_source source,
    bool               always_set_to_false,
    rtems_fatal_code   code
  )
  {
    rtems_status_code sc;

    FatalExtension( source, always_set_to_false, code, 5 );

    sc = rtems_extension_delete( extension_ids[ 5 ] );
    T_quiet_rsc_success( sc );
  }

  static void FatalExtension6(
    rtems_fatal_source source,
    bool               always_set_to_false,
    rtems_fatal_code   code
  )
  {
    rtems_status_code sc;

    FatalExtension( source, always_set_to_false, code, 6 );

    sc = rtems_extension_delete( extension_ids[ 4 ] );
    T_quiet_rsc_success( sc );
  }
test-target: testsuites/validation/tc-terminate.c
test-teardown: null
type: test-case