SPDX-License-Identifier: CC-BY-SA-4.0 OR BSD-2-Clause
copyrights:
- Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de)
enabled-by: true
functional-type: action
links:
- role: interface-function
  uid: ../if/create
post-conditions:
- name: Status
  states:
  - name: Ok
    test-code: |
      T_rsc_success( ctx->status );
      T_eq_ptr( ctx->id, &ctx->id_value );
      T_ne_u32( ctx->id_value, 0xffffffff );

      id = 0xffffffff;
      sc = rtems_partition_ident( PART_NAME, RTEMS_SEARCH_LOCAL_NODE, &id );
      T_rsc_success( sc );
      T_eq_u32( id, ctx->id_value );

      for ( i = 0; i < BUFFER_COUNT; ++i) {
        sc = rtems_partition_get_buffer( ctx->id_value, &buffers[ i ] );
        T_rsc_success( sc );
        T_not_null( buffers[ i ] );
      }

      no_buffer = (void *) (uintptr_t) 1;
      sc = rtems_partition_get_buffer( ctx->id_value, &no_buffer );
      T_rsc( sc, RTEMS_UNSATISFIED );
      T_eq_ptr( no_buffer, (void *) (uintptr_t) 1 );

      for ( i = 0; i < BUFFER_COUNT; ++i) {
        sc = rtems_partition_return_buffer( ctx->id_value, buffers[ i ] );
        T_rsc_success( sc );
      }

      sc = rtems_partition_delete( ctx->id_value );
      T_rsc_success( sc );
    text: |
      The status shall be RTEMS_SUCCESSFUL.  The value of the object identifier
      referenced by the id parameter shall identify the created partition.
  - name: InvAddress
    test-code: |
      T_rsc( ctx->status, RTEMS_INVALID_ADDRESS );
      T_eq_u32( ctx->id_value, 0xffffffff );
    text: |
      The status shall be RTEMS_INVALID_ADDRESS.
  - name: InvName
    test-code: |
      T_rsc( ctx->status, RTEMS_INVALID_NAME );
      T_eq_u32( ctx->id_value, 0xffffffff );
    text: |
      The status shall be RTEMS_INVALID_NAME.  If the id parameter is not NULL,
      then the value of the object identifier referenced by the id parameter
      shall be unchanged.
  - name: InvNumber
    test-code: |
      T_rsc( ctx->status, RTEMS_INVALID_NUMBER );
      T_eq_u32( ctx->id_value, 0xffffffff );
    text: |
      The status shall be RTEMS_INVALID_NUMBER.  If the id parameter is not
      NULL, then the value of the object identifier referenced by the id
      parameter shall be unchanged.
  - name: InvSize
    test-code: |
      T_rsc( ctx->status, RTEMS_INVALID_SIZE );
      T_eq_u32( ctx->id_value, 0xffffffff );
    text: |
      The status shall be RTEMS_INVALID_SIZE.  If the id parameter is not NULL,
      then the value of the object identifier referenced by the id parameter
      shall be unchanged.
  - name: TooMany
    test-code: |
      T_rsc( ctx->status, RTEMS_TOO_MANY );
      T_eq_u32( ctx->id_value, 0xffffffff );
    text: |
      The status shall be RTEMS_TOO_MANY.  If the id parameter is not NULL,
      then the value of the object identifier referenced by the id parameter
      shall be unchanged.
  test-epilogue: null
  test-prologue: |
    rtems_status_code sc;
    rtems_id          id;
    size_t            i;
    void             *buffers[ BUFFER_COUNT ];
    void             *no_buffer;
pre-conditions:
- name: Id
  states:
  - name: Id
    test-code: |
      ctx->id = &ctx->id_value;
    text: |
      The id parameter shall reference an object identifier value.
  - name: 'Null'
    test-code: |
      ctx->id = NULL;
    text: |
      The id parameter shall be NULL.
  test-epilogue: null
  test-prologue: null
- name: Name
  states:
  - name: Valid
    test-code: |
      ctx->name = PART_NAME;
    text: |
      The name of the partition shall be valid.
  - name: Invalid
    test-code: |
      ctx->name = 0;
    text: |
      The name of the partition shall be invalid.
  test-epilogue: null
  test-prologue: null
- name: Start
  states:
  - name: Valid
    test-code: |
      ctx->starting_address = buffers;
    text: |
      The starting address of the buffer area shall be valid.
  - name: 'Null'
    test-code: |
      ctx->starting_address = NULL;
    text: |
      The starting address of the buffer area shall be NULL.
  - name: BadAlign
    test-code: |
      ctx->starting_address = &buffers[ 0 ][ 1 ];
    text: |
      The starting address of the buffer area shall be misaligned.
  test-epilogue: null
  test-prologue: null
- name: Length
  states:
  - name: Valid
    test-code: |
      ctx->length = sizeof( buffers );
    text: |
      The length of the buffer area shall be valid.
  - name: Zero
    test-code: |
      ctx->length = 0;
    text: |
      The length of the buffer area shall be zero.
  - name: Invalid
    test-code: |
      ctx->length = sizeof( buffers[ 0 ] ) - 1;
    text: |
      The length of the buffer area shall be less than the buffer size.
  test-epilogue: null
  test-prologue: null
- name: Size
  states:
  - name: Valid
    test-code: |
      ctx->buffer_size = sizeof( buffers[ 0 ] );
    text: |
      The buffer size shall be valid.
  - name: Zero
    test-code: |
      ctx->buffer_size = 0;
    text: |
      The buffer size shall be zero.
  - name: Small
    test-code: |
      ctx->buffer_size = sizeof( buffers[ 0 ] ) - 1;
    text: |
      The buffer size shall be less than the size of two pointers.
  test-epilogue: null
  test-prologue: null
- name: Parts
  states:
  - name: Avail
    test-code: |
      /* Nothing to do */
    text: |
      There shall be at least one inactive partition object available.
  - name: None
    test-code: |
      i = 0;

      while ( i < MAX_PARTITIONS ) {
        rtems_status_code sc;
        rtems_id          id;

        sc = rtems_partition_create(
          rtems_build_name( 'P', 'A', 'R', 'T' ),
          exhaust_buffers[ i ],
          sizeof( exhaust_buffers[ i ] ),
          sizeof( exhaust_buffers[ i ][ 0 ] ),
          RTEMS_DEFAULT_ATTRIBUTES,
          &id
        );

        if ( sc == RTEMS_SUCCESSFUL ) {
          Objects_Control           *obj;
          const Objects_Information *info;

          info = _Objects_Get_information_id( id );
          T_quiet_assert_not_null( info );
          obj = _Objects_Get_no_protection( id, info );
          T_quiet_assert_not_null( obj );
          _Chain_Append_unprotected( &ctx->partitions, &obj->Node );
        } else {
          T_quiet_rsc( sc, RTEMS_TOO_MANY );
          break;
        }

        ++i;
      }
    text: |
      There shall be no inactive partition object available.
  test-epilogue: null
  test-prologue: |
    size_t i;
rationale: null
references: []
requirement-type: functional
skip-reasons: {}
test-action: |
  ctx->status = rtems_partition_create(
    ctx->name,
    ctx->starting_address,
    ctx->length,
    ctx->buffer_size,
    ctx->attribute_set,
    ctx->id
  );
test-brief: null
test-cleanup: |
  Chain_Node *node;

  while ( ( node = _Chain_Get_unprotected( &ctx->partitions ) ) ) {
    Objects_Control   *obj;
    rtems_status_code  sc;

    obj = (Objects_Control *) node;
    sc = rtems_partition_delete( obj->id );
    T_quiet_rsc_success( sc );
  }
test-context:
- brief: null
  description: null
  member: rtems_status_code status
- brief: null
  description: null
  member: rtems_name name
- brief: null
  description: null
  member: void *starting_address
- brief: null
  description: null
  member: uintptr_t length
- brief: null
  description: null
  member: size_t buffer_size
- brief: null
  description: null
  member: rtems_attribute attribute_set
- brief: null
  description: null
  member: rtems_id *id
- brief: null
  description: null
  member: rtems_id id_value
- brief: null
  description: null
  member: Chain_Control partitions
test-context-support: null
test-description: null
test-header: null
test-includes:
- rtems.h
- rtems/score/chainimpl.h
- rtems/score/objectimpl.h
- string.h
test-local-includes: []
test-prepare: |
  rtems_status_code sc;
  rtems_id          id;

  ctx->id_value = 0xffffffff;
  ctx->attribute_set = RTEMS_DEFAULT_ATTRIBUTES;

  id = 0xffffffff;
  sc = rtems_partition_ident( PART_NAME, RTEMS_SEARCH_LOCAL_NODE, &id );
  T_rsc( sc, RTEMS_INVALID_NAME );
  T_eq_u32( id, 0xffffffff );
test-setup:
  brief: null
  code: |
    _Chain_Initialize_empty( &ctx->partitions );
  description: null
test-stop: null
test-support: |
  #define PART_NAME rtems_build_name( 'N', 'A', 'M', 'E' )

  #define MAX_PARTITIONS 4

  #define BUFFER_COUNT 2

  #define BUFFER_SIZE ( 2 * sizeof( void * ) )

  static RTEMS_ALIGNED( RTEMS_PARTITION_ALIGNMENT ) uint8_t
    exhaust_buffers[ MAX_PARTITIONS ][ BUFFER_COUNT ][ BUFFER_SIZE ];

  static RTEMS_ALIGNED( RTEMS_PARTITION_ALIGNMENT ) uint8_t
    buffers[ BUFFER_COUNT ][ BUFFER_SIZE ];
test-target: testsuites/validation/tc-part-create.c
test-teardown: null
text: ${.:text-template}
transition-map:
- enabled-by: true
  post-conditions:
    Status: Ok
  pre-conditions:
    Id:
    - Id
    Length:
    - Valid
    Name:
    - Valid
    Parts:
    - Avail
    Size:
    - Valid
    Start:
    - Valid
- enabled-by: true
  post-conditions:
    Status: InvName
  pre-conditions:
    Id: all
    Length: all
    Name:
    - Invalid
    Parts: all
    Size: all
    Start: all
- enabled-by: true
  post-conditions:
    Status: InvAddress
  pre-conditions:
    Id:
    - 'Null'
    Length: all
    Name:
    - Valid
    Parts: all
    Size: all
    Start: all
- enabled-by: true
  post-conditions:
    Status: InvAddress
  pre-conditions:
    Id:
    - Id
    Length: all
    Name:
    - Valid
    Parts: all
    Size: all
    Start:
    - 'Null'
- enabled-by: true
  post-conditions:
    Status: InvSize
  pre-conditions:
    Id:
    - Id
    Length:
    - Zero
    - Invalid
    Name:
    - Valid
    Parts: all
    Size: all
    Start:
    - Valid
    - BadAlign
- enabled-by: true
  post-conditions:
    Status: InvSize
  pre-conditions:
    Id:
    - Id
    Length:
    - Valid
    Name:
    - Valid
    Parts: all
    Size:
    - Zero
    - Small
    Start:
    - Valid
    - BadAlign
- enabled-by: true
  post-conditions:
    Status: InvAddress
  pre-conditions:
    Id:
    - Id
    Length:
    - Valid
    Name:
    - Valid
    Parts: all
    Size:
    - Valid
    Start:
    - BadAlign
- enabled-by: true
  post-conditions:
    Status: TooMany
  pre-conditions:
    Id:
    - Id
    Length:
    - Valid
    Name:
    - Valid
    Parts:
    - None
    Size:
    - Valid
    Start:
    - Valid
type: requirement