test/secure_fw/suites/nsid/nsid_testsuite.c

/*
 * Copyright (c) 2021-2022, Arm Limited. All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 *
 */

#include <stdint.h>
#include "test_framework.h"
#include "tfm_ns_client_ext.h"
#include "nsid_svc_handler.h"
#include "tfm_nsid_manager.h"

/*
 * The following macros are defined for white-box test only.
 * Some of them are duplicated from secure side.
 * It is unnecessary to export these definitions to NS side in actual scenarios.
 */
#define MAKE_NS_CLIENT_TOKEN(tid, gid, idx)                         \
                             (uint32_t)((((uint32_t)tid & 0xff)     \
                             | (((uint32_t)gid & 0xff) << 8)        \
                             | (((uint32_t)idx & 0xff) << 16))      \
                             & 0x00ffffff)

#define VALID_INDEX                   0x00
#define VALID_GROUP_ID                0x00
#define VALID_THREAD_ID_MIN           0x00
#define VALID_THREAD_ID_MAX           UINT8_MAX
#define VALID_NSID_MAX                ((int32_t)-1)
#define VALID_NSID_MIN                INT32_MIN
#define INVALID_INDEX                 0x01
#define INVALID_GROUP_ID              0x01
#define INVALID_RESERVED_TOKEN_BIT    0x10000000
#define TFM_NS_CONTEXT_MAX            1

static uint8_t thread_id = 0x20;
static int32_t nsid = -500;

/*
 * This func is to be called at the beginning of test cases.
 * The current active token needs to be saved first
 * before calling ns_client_ext APIs through NS SVC.
 * Values of NSID and Thread ID are changed to make sure
 * every test case could be assigned with different tokens.
 */
static void nsid_test_case_init(struct test_result_t *ret)
{
    if (nsid_save_ctx_svc(current_active_token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("SAVE fail when saving test thread ctx\r\n");
    }

    nsid--;
    thread_id++;

    return;
}

/*
 * This func is to be called at the end of test cases
 * to re-load the saved token at the beginning of the test case.
 */
static void nsid_test_case_finish(struct test_result_t *ret)
{
    if (nsid_load_ctx_svc(current_active_token,
                          nsid_mgr_query_nsid(current_active_token))
        != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("LOAD fail when re-loading test thread ctx\r\n");
    }
    return;
}

/* Initialize with valid params */
static void tfm_nsid_test_case_1(struct test_result_t *ret)
{
    nsid_test_case_init(ret);

    if (nsid_ext_init_svc(0) != TFM_NS_CONTEXT_MAX) {
        TEST_FAIL("INITIALIZE shall return TFM_NS_CONTEXT_MAX\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_ext_init_svc(1) != 1) {
        TEST_FAIL("INITIALIZE shall return 1\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_ext_init_svc(TFM_NS_CONTEXT_MAX + 1) != TFM_NS_CONTEXT_MAX) {
        TEST_FAIL("INITIALIZE shall return TFM_NS_CONTEXT_MAX\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    ret->val = TEST_PASSED;

    nsid_test_case_finish(ret);
}

/* Normal full sequence */
static void tfm_nsid_test_case_2(struct test_result_t *ret)
{
    uint32_t token;

    nsid_test_case_init(ret);

    token = nsid_acquire_ctx_svc(VALID_GROUP_ID, thread_id);

    if (token != MAKE_NS_CLIENT_TOKEN(thread_id, VALID_GROUP_ID, VALID_INDEX)) {
        TEST_FAIL("ACQUIRE shall return a valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(token, nsid) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("LOAD shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_save_ctx_svc(token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("SAVE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    ret->val = TEST_PASSED;

    nsid_test_case_finish(ret);
}

/* Normal acquire-release sequence */
static void tfm_nsid_test_case_3(struct test_result_t *ret)
{
    uint32_t token;

    nsid_test_case_init(ret);

    token = nsid_acquire_ctx_svc(VALID_GROUP_ID, thread_id);

    if (token != MAKE_NS_CLIENT_TOKEN(thread_id, VALID_GROUP_ID, VALID_INDEX)) {
        TEST_FAIL("ACQUIRE shall return a valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    ret->val = TEST_PASSED;

    nsid_test_case_finish(ret);
}

/*  Normal acquire-load-release sequence */
static void tfm_nsid_test_case_4(struct test_result_t *ret)
{
    uint32_t token;

    nsid_test_case_init(ret);

    token = nsid_acquire_ctx_svc(VALID_GROUP_ID, thread_id);

    if (token != MAKE_NS_CLIENT_TOKEN(thread_id, VALID_GROUP_ID, VALID_INDEX)) {
        TEST_FAIL("ACQUIRE shall return a valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(token, nsid) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("LOAD shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    ret->val = TEST_PASSED;

    nsid_test_case_finish(ret);
}

/* Switch contexts */
static void tfm_nsid_test_case_5(struct test_result_t *ret)
{
    uint32_t token_a;
    uint32_t token_b;

    nsid_test_case_init(ret);

    token_a = nsid_acquire_ctx_svc(VALID_GROUP_ID, thread_id);
    token_b = nsid_acquire_ctx_svc(VALID_GROUP_ID, thread_id + 1);

    if (token_a != MAKE_NS_CLIENT_TOKEN(thread_id, \
                                        VALID_GROUP_ID, \
                                        VALID_INDEX) || \
        token_b != MAKE_NS_CLIENT_TOKEN(thread_id + 1, \
                                        VALID_GROUP_ID, \
                                        VALID_INDEX)) {
        TEST_FAIL("ACQUIRE shall return a valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(token_a, nsid) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("LOAD shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_save_ctx_svc(token_a) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("SAVE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(token_b, nsid) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("LOAD shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_save_ctx_svc(token_b) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("SAVE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token_a) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token_b) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    ret->val = TEST_PASSED;

    nsid_test_case_finish(ret);
}

/* Release inactive context */
static void tfm_nsid_test_case_6(struct test_result_t *ret)
{
    uint32_t token_a;
    uint32_t token_b;

    nsid_test_case_init(ret);

    token_a = nsid_acquire_ctx_svc(VALID_GROUP_ID, thread_id);
    token_b = nsid_acquire_ctx_svc(VALID_GROUP_ID, thread_id + 1);

    if (token_a != MAKE_NS_CLIENT_TOKEN(thread_id, \
                                        VALID_GROUP_ID,
                                        VALID_INDEX) || \
        token_b != MAKE_NS_CLIENT_TOKEN(thread_id + 1, \
                                        VALID_GROUP_ID, \
                                        VALID_INDEX)) {
        TEST_FAIL("ACQUIRE shall return a valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(token_a, nsid) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("LOAD shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token_b) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token_a) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    ret->val = TEST_PASSED;

    nsid_test_case_finish(ret);
}

/* Max NSID */
static void tfm_nsid_test_case_7(struct test_result_t *ret)
{
    uint32_t token;

    nsid_test_case_init(ret);

    token = nsid_acquire_ctx_svc(VALID_GROUP_ID, thread_id);

    if (token != MAKE_NS_CLIENT_TOKEN(thread_id, VALID_GROUP_ID, VALID_INDEX)) {
        TEST_FAIL("ACQUIRE shall return a valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(token, VALID_NSID_MAX)
        != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("LOAD shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_save_ctx_svc(token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("SAVE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    ret->val = TEST_PASSED;

    nsid_test_case_finish(ret);
}

/* Min NSID */
static void tfm_nsid_test_case_8(struct test_result_t *ret)
{
    uint32_t token;

    nsid_test_case_init(ret);

    token = nsid_acquire_ctx_svc(VALID_GROUP_ID, thread_id);

    if (token != MAKE_NS_CLIENT_TOKEN(thread_id, VALID_GROUP_ID, VALID_INDEX)) {
        TEST_FAIL("ACQUIRE shall return a valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(token, VALID_NSID_MIN)
        != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("LOAD shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_save_ctx_svc(token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("SAVE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    ret->val = TEST_PASSED;

    nsid_test_case_finish(ret);
}

/* Min TID */
static void tfm_nsid_test_case_9(struct test_result_t *ret)
{
    uint32_t token;

    nsid_test_case_init(ret);

    token = nsid_acquire_ctx_svc(VALID_GROUP_ID, VALID_THREAD_ID_MIN);

    if (token != MAKE_NS_CLIENT_TOKEN(0x00, VALID_GROUP_ID, VALID_INDEX)) {
        TEST_FAIL("ACQUIRE shall return a valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(token, nsid) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("LOAD shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_save_ctx_svc(token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("SAVE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    ret->val = TEST_PASSED;

    nsid_test_case_finish(ret);
}

/* Max TID */
static void tfm_nsid_test_case_10(struct test_result_t *ret)
{
    uint32_t token;

    nsid_test_case_init(ret);

    token = nsid_acquire_ctx_svc(VALID_GROUP_ID, VALID_THREAD_ID_MAX);

    if (token != MAKE_NS_CLIENT_TOKEN(0xFF, VALID_GROUP_ID, VALID_INDEX)) {
        TEST_FAIL("ACQUIRE shall return a valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(token, nsid) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("LOAD shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_save_ctx_svc(token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("SAVE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    ret->val = TEST_PASSED;

    nsid_test_case_finish(ret);
}

/* Load Thread B without saving Thread A */
static void tfm_nsid_test_case_11(struct test_result_t *ret)
{
    uint32_t token_a;
    uint32_t token_b;

    nsid_test_case_init(ret);

    token_a = nsid_acquire_ctx_svc(VALID_GROUP_ID, thread_id);
    token_b = nsid_acquire_ctx_svc(VALID_GROUP_ID, thread_id + 1);

    if (token_a != MAKE_NS_CLIENT_TOKEN(thread_id, \
                                        VALID_GROUP_ID, \
                                        VALID_INDEX) || \
        token_b != MAKE_NS_CLIENT_TOKEN(thread_id + 1, \
                                        VALID_GROUP_ID, \
                                        VALID_INDEX)) {
        TEST_FAIL("ACQUIRE shall return a valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(token_a, nsid) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("LOAD shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(token_b, nsid) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("LOAD shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token_a) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token_b) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    ret->val = TEST_PASSED;

    nsid_test_case_finish(ret);
}

/* Load with non-negative NSID */
static void tfm_nsid_test_case_12(struct test_result_t *ret)
{
    uint32_t token;

    nsid_test_case_init(ret);

    thread_id++;

    token = nsid_acquire_ctx_svc(VALID_GROUP_ID, thread_id);

    if (token != MAKE_NS_CLIENT_TOKEN(thread_id, VALID_GROUP_ID, VALID_INDEX)) {
        TEST_FAIL("ACQUIRE shall return a valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(token, 0) != TFM_NS_CLIENT_ERR_INVALID_NSID) {
        TEST_FAIL("LOAD shall fail with non-negative NSID\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(token, 1) != TFM_NS_CLIENT_ERR_INVALID_NSID) {
        TEST_FAIL("LOAD shall fail with non-negative NSID\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(token, 50) != TFM_NS_CLIENT_ERR_INVALID_NSID) {
        TEST_FAIL("LOAD shall fail with non-negative NSID\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    nsid_test_case_finish(ret);

    ret->val = TEST_PASSED;
}

/* Load with invalid token */
static void tfm_nsid_test_case_13(struct test_result_t *ret)
{
    uint32_t token;

    nsid_test_case_init(ret);

    token = nsid_acquire_ctx_svc(VALID_GROUP_ID, thread_id);

    if (token != MAKE_NS_CLIENT_TOKEN(thread_id, VALID_GROUP_ID, VALID_INDEX)) {
        TEST_FAIL("ACQUIRE shall return a valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(TFM_NS_CLIENT_INVALID_TOKEN, nsid)
        != TFM_NS_CLIENT_ERR_INVALID_TOKEN) {
        TEST_FAIL("LOAD shall fail with invalid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    ret->val = TEST_PASSED;

    nsid_test_case_finish(ret);
}

/* Save with invalid token */
static void tfm_nsid_test_case_14(struct test_result_t *ret)
{
    uint32_t token;

    nsid_test_case_init(ret);

    token = nsid_acquire_ctx_svc(VALID_GROUP_ID, thread_id);

    if (token != MAKE_NS_CLIENT_TOKEN(thread_id, VALID_GROUP_ID, VALID_INDEX)) {
        TEST_FAIL("ACQUIRE shall return a valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(token, nsid) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("LOAD shall pass with valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_save_ctx_svc(TFM_NS_CLIENT_INVALID_TOKEN)
        != TFM_NS_CLIENT_ERR_INVALID_TOKEN) {
        TEST_FAIL("SAVE shall fail with invalid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    ret->val = TEST_PASSED;

    nsid_test_case_finish(ret);
}

/* Release with invalid token */
static void tfm_nsid_test_case_15(struct test_result_t *ret)
{
    uint32_t token;

    nsid_test_case_init(ret);

    token = nsid_acquire_ctx_svc(VALID_GROUP_ID, thread_id);

    if (token != MAKE_NS_CLIENT_TOKEN(thread_id, VALID_GROUP_ID, VALID_INDEX)) {
        TEST_FAIL("ACQUIRE shall return a valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(TFM_NS_CLIENT_INVALID_TOKEN)
        != TFM_NS_CLIENT_ERR_INVALID_TOKEN) {
        TEST_FAIL("RELEASE shall fail with invalid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    ret->val = TEST_PASSED;

    nsid_test_case_finish(ret);
}

/* Acquire with undefault GID */
static void tfm_nsid_test_case_16(struct test_result_t *ret)
{
    nsid_test_case_init(ret);

    if (nsid_acquire_ctx_svc(0x01, INVALID_GROUP_ID) \
        != TFM_NS_CLIENT_INVALID_TOKEN) {
        TEST_FAIL("ACQUIRE shall fail with invalid GID\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_acquire_ctx_svc(0x50, INVALID_GROUP_ID) \
        != TFM_NS_CLIENT_INVALID_TOKEN) {
        TEST_FAIL("ACQUIRE shall fail with invalid GID\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_acquire_ctx_svc(0xFF, INVALID_GROUP_ID) \
        != TFM_NS_CLIENT_INVALID_TOKEN) {
        TEST_FAIL("ACQUIRE shall fail with invalid GID\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    ret->val = TEST_PASSED;

    nsid_test_case_finish(ret);
}

/* Load, save and release with token containing wrong info */
static void tfm_nsid_test_case_17(struct test_result_t *ret)
{
    uint32_t token;

    nsid_test_case_init(ret);

    token = nsid_acquire_ctx_svc(VALID_GROUP_ID, thread_id);

    if (token != MAKE_NS_CLIENT_TOKEN(thread_id, VALID_GROUP_ID, VALID_INDEX)) {
        TEST_FAIL("ACQUIRE shall return a valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(MAKE_NS_CLIENT_TOKEN(thread_id, \
                                               INVALID_GROUP_ID, \
                                               VALID_INDEX), nsid) \
        != TFM_NS_CLIENT_ERR_INVALID_TOKEN) {
        TEST_FAIL("LOAD shall fail with token with wrong GID\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(MAKE_NS_CLIENT_TOKEN(thread_id, \
                                               VALID_GROUP_ID, \
                                               INVALID_INDEX), nsid) \
        != TFM_NS_CLIENT_ERR_INVALID_TOKEN) {
        TEST_FAIL("LOAD shall fail with token with wrong index\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(MAKE_NS_CLIENT_TOKEN(thread_id, \
                                               VALID_GROUP_ID, \
                                               VALID_INDEX) \
                          | INVALID_RESERVED_TOKEN_BIT, nsid) \
        != TFM_NS_CLIENT_ERR_INVALID_TOKEN) {
        TEST_FAIL("LOAD shall fail with token with wrong reserved bits\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(token, nsid) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("LOAD shall pass with valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_save_ctx_svc(MAKE_NS_CLIENT_TOKEN(0xF0, \
                                               VALID_GROUP_ID, \
                                               VALID_INDEX)) \
        != TFM_NS_CLIENT_ERR_INVALID_TOKEN) {
        TEST_FAIL("SAVE shall fail with token with wrong TID\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_save_ctx_svc(MAKE_NS_CLIENT_TOKEN(thread_id, \
                                               INVALID_GROUP_ID, \
                                               VALID_INDEX)) \
        != TFM_NS_CLIENT_ERR_INVALID_TOKEN) {
        TEST_FAIL("SAVE shall fail with token with wrong GID\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_save_ctx_svc(MAKE_NS_CLIENT_TOKEN(thread_id, \
                                               VALID_GROUP_ID, \
                                               INVALID_INDEX)) \
        != TFM_NS_CLIENT_ERR_INVALID_TOKEN) {
        TEST_FAIL("SAVE shall fail with token with wrong index\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_save_ctx_svc(MAKE_NS_CLIENT_TOKEN(thread_id, \
                                               VALID_GROUP_ID, \
                                               VALID_INDEX) \
                          | INVALID_RESERVED_TOKEN_BIT) \
        != TFM_NS_CLIENT_ERR_INVALID_TOKEN) {
        TEST_FAIL("SAVE shall fail with token with wrong reserved bits\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_save_ctx_svc(token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("SAVE shall pass with valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(MAKE_NS_CLIENT_TOKEN(thread_id, \
                                                  INVALID_GROUP_ID, \
                                                  VALID_INDEX)) \
        != TFM_NS_CLIENT_ERR_INVALID_TOKEN) {
        TEST_FAIL("RELEASE shall fail with token with wrong GID\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(MAKE_NS_CLIENT_TOKEN(thread_id, \
                                                  VALID_GROUP_ID, \
                                                  INVALID_INDEX)) \
        != TFM_NS_CLIENT_ERR_INVALID_TOKEN) {
        TEST_FAIL("RELEASE shall fail with token with wrong index\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(MAKE_NS_CLIENT_TOKEN(thread_id, \
                                               VALID_GROUP_ID, \
                                               VALID_INDEX) \
                          | INVALID_RESERVED_TOKEN_BIT) \
        != TFM_NS_CLIENT_ERR_INVALID_TOKEN) {
        TEST_FAIL("RELEASE shall fail with token with wrong reserved bits\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    ret->val = TEST_PASSED;

    nsid_test_case_finish(ret);
}

/* Save without loading */
static void tfm_nsid_test_case_18(struct test_result_t *ret)
{
    uint32_t token;

    nsid_test_case_init(ret);

    token = nsid_acquire_ctx_svc(VALID_GROUP_ID, thread_id);

    if (token != MAKE_NS_CLIENT_TOKEN(thread_id, VALID_GROUP_ID, VALID_INDEX)) {
        TEST_FAIL("ACQUIRE shall return a valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_save_ctx_svc(token) != TFM_NS_CLIENT_ERR_INVALID_TOKEN) {
        TEST_FAIL("SAVE shall fail when not loaded\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    ret->val = TEST_PASSED;

    nsid_test_case_finish(ret);
}

/* Save released context */
static void tfm_nsid_test_case_19(struct test_result_t *ret)
{
    uint32_t token;

    nsid_test_case_init(ret);

    token = nsid_acquire_ctx_svc(VALID_GROUP_ID, thread_id);

    if (token != MAKE_NS_CLIENT_TOKEN(thread_id, VALID_GROUP_ID, VALID_INDEX)) {
        TEST_FAIL("ACQUIRE shall return a valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_save_ctx_svc(token) != TFM_NS_CLIENT_ERR_INVALID_TOKEN) {
        TEST_FAIL("SAVE shall fail with released token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    ret->val = TEST_PASSED;

    nsid_test_case_finish(ret);
}

/* Save inactive context */
static void tfm_nsid_test_case_20(struct test_result_t *ret)
{
    uint32_t token_a;
    uint32_t token_b;

    nsid_test_case_init(ret);

    token_a = nsid_acquire_ctx_svc(VALID_GROUP_ID, thread_id);
    token_b = nsid_acquire_ctx_svc(VALID_GROUP_ID, thread_id + 1);

    if (token_a != MAKE_NS_CLIENT_TOKEN(thread_id, \
                                        VALID_GROUP_ID, \
                                        VALID_INDEX) || \
        token_b != MAKE_NS_CLIENT_TOKEN(thread_id + 1, \
                                        VALID_GROUP_ID, \
                                        VALID_INDEX)) {
        TEST_FAIL("ACQUIRE shall return a valid token\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_load_ctx_svc(token_a, nsid) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("LOAD shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_save_ctx_svc(token_b) != TFM_NS_CLIENT_ERR_INVALID_TOKEN) {
        TEST_FAIL("SAVE shall fail with inactive token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token_a) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (nsid_release_ctx_svc(token_b) != TFM_NS_CLIENT_ERR_SUCCESS) {
        TEST_FAIL("RELEASE shall success with valid token value\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    ret->val = TEST_PASSED;

    nsid_test_case_finish(ret);
}

/* Call in thread mode */
static void tfm_nsid_test_case_21(struct test_result_t *ret)
{
    uint32_t token;

    nsid_test_case_init(ret);

    if (tfm_nsce_init(0) != 0) {
        TEST_FAIL("INITIALIZE shall not success in thread mode\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    token = tfm_nsce_acquire_ctx(VALID_GROUP_ID, thread_id);

    if (token != TFM_NS_CLIENT_ERR_INVALID_ACCESS) {
        TEST_FAIL("ACQUIRE shall not success in thread mode\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (tfm_nsce_load_ctx(token, nsid) != TFM_NS_CLIENT_ERR_INVALID_ACCESS) {
        TEST_FAIL("LOAD shall not success in thread mode\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (tfm_nsce_save_ctx(token) != TFM_NS_CLIENT_ERR_INVALID_ACCESS) {
        TEST_FAIL("SAVE shall not success in thread mode\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    if (tfm_nsce_release_ctx(token) != TFM_NS_CLIENT_ERR_INVALID_ACCESS) {
        TEST_FAIL("RELEASE shall not success in thread mode\r\n");
        nsid_test_case_finish(ret);
        return;
    }

    ret->val = TEST_PASSED;

    nsid_test_case_finish(ret);
}

static struct test_t nsid_test_cases[] = {
    /* Normal test */
    {&tfm_nsid_test_case_1, "TFM_NS_NSID_TEST_1001",
     "NSID management initialize ctx pass"},
    {&tfm_nsid_test_case_2, "TFM_NS_NSID_TEST_1002",
     "NSID management normal full sequence pass"},
    {&tfm_nsid_test_case_3, "TFM_NS_NSID_TEST_1003",
     "NSID management acquire-release sequence pass"},
    {&tfm_nsid_test_case_4, "TFM_NS_NSID_TEST_1004",
     "NSID management acquire-load-release sequence pass"},
    {&tfm_nsid_test_case_5, "TFM_NS_NSID_TEST_1005",
     "NSID management switching contexts pass"},
    {&tfm_nsid_test_case_6, "TFM_NS_NSID_TEST_1006",
     "NSID management releasing inactive context pass"},
    /* Corner case test */
    {&tfm_nsid_test_case_7, "TFM_NS_NSID_TEST_1007",
     "NSID management pass with max valid NSID"},
    {&tfm_nsid_test_case_8, "TFM_NS_NSID_TEST_1008",
     "NSID management pass with min valid NSID"},
    {&tfm_nsid_test_case_9, "TFM_NS_NSID_TEST_1009",
     "NSID management pass with min TID"},
    {&tfm_nsid_test_case_10, "TFM_NS_NSID_TEST_1010",
     "NSID management pass with max TID"},
    {&tfm_nsid_test_case_11, "TFM_NS_NSID_TEST_1011",
     "NSID management pass when loading B without saving A"},
    /* Error test */
    /* Wrong params */
    {&tfm_nsid_test_case_12, "TFM_NS_NSID_TEST_1012",
     "NSID management loading fail with non-negative NSID"},
    {&tfm_nsid_test_case_13, "TFM_NS_NSID_TEST_1013",
     "NSID management fail when loading with invalid token"},
    {&tfm_nsid_test_case_14, "TFM_NS_NSID_TEST_1014",
     "NSID management fail when saving with invalid token"},
    {&tfm_nsid_test_case_15, "TFM_NS_NSID_TEST_1015",
     "NSID management fail when releasing with invalid token"},
    {&tfm_nsid_test_case_16, "TFM_NS_NSID_TEST_1016",
     "NSID management fail when acquiring with undefault GID"},
    {&tfm_nsid_test_case_17, "TFM_NS_NSID_TEST_1017",
     "NSID management fail with token containing wrong info"},
    /* Wrong sequence */
    {&tfm_nsid_test_case_18, "TFM_NS_NSID_TEST_1018",
     "NSID management fail when saving without loading"},
    {&tfm_nsid_test_case_19, "TFM_NS_NSID_TEST_1019",
     "NSID management fail when saving released token"},
    {&tfm_nsid_test_case_20, "TFM_NS_NSID_TEST_1020",
     "NSID management fail when saving inactive token"},
    /* Other tests */
    {&tfm_nsid_test_case_21, "TFM_NS_NSID_TEST_1021",
     "NSID management fail when called in thread mode"},
};

void register_testsuite_nsid_test(struct test_suite_t *p_test_suite)
{
    uint32_t list_size;

    list_size = (sizeof(nsid_test_cases) / sizeof(nsid_test_cases[0]));

    set_testsuite("TFM NSID Test (TFM_NSID_TEST_1xxx)",
                  nsid_test_cases, list_size, p_test_suite);
}