/*
 * Copyright (c) 2021, Google Inc. All rights reserved
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files
 * (the "Software"), to deal in the Software without restriction,
 * including without limitation the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#define LOCAL_TRACE (0)

#include <kernel/debug.h>
#include <kernel/event.h>
#include <kernel/mutex.h>
#include <kernel/thread.h>
#include <lib/unittest/unittest.h>
#include <lk/init.h>
#include <lk/trace.h>
#include <stdbool.h>
#include <stdio.h>

#define PINCPU_TEST_CPU_COUNT 4

/*
 * Test verifying cpu pinning on any thread state
 * Make sure cpu pinning can be dynamically set on
 * a running, ready, blocked or sleeping thread.
 */

/**
 * struct pincputest_thread_ctx_main - main thread context structure
 * @test_state:               Current test state
 * @thread:                   `main` thread's thread structure
 * @ev_req:                   Request event sent by the unittest thread to
 *                            the main thread in order to start a new test
 * @ev_resp:                  Response event sent by the main thread to
 *                            the unittest thread when the test case is
 *                            complete
 * @runningstate_lock:        Spin_lock used to ensure the unittest thread
 *                            waits in running state. This is used to keep
 *                            the peer thread in ready state.
 * @cpu_expected:             Cpu on which the main thread is pinned to and
 *                            shall be running on when setting the peer
 *                            thread's pinned cpu.
 * @actual_pinned_cpu:        Peer thread's pinned cpu as seen by the main
 *                            thread when the thread_set_pinned_cpu is complete
 */
struct pincputest_thread_ctx_main {
    void* test_state;
    thread_t* thread;
    event_t ev_req;
    event_t ev_resp;
    spin_lock_t runningstate_lock;
    int cpu_expected;
    int actual_pinned_cpu;
};

/**
 * struct pincputest_thread_ctx_peer - peer thread context structure
 * @test_state:               Current test state
 * @thread:                   `peer` thread's thread structure
 * @ev_req:                   Request event sent by the main thread to
 *                            the peer thread.
 * @ev_resp:                  Response event sent by the peer thread to
 *                            the main thread
 * @blockingstate_mutex:      Mutex used to set the peer thread
 *                            in blocking state
 * @blockingstate_event:      Event used to set the peer thread
 *                            in blocking state, as an additional option
 *                            to the mutex.
 * @runningstate_lock:        Spin_lock used to set the peer thread
 *                            in running state.
 * @cpu_expected:             Cpu on which the peer thread is pinned to.
 * @cpu_actual:               Cpu on which the peer thread is running
 *                            after handling the request event
 *                            from the main thread
 */
struct pincputest_thread_ctx_peer {
    void* test_state;
    thread_t* thread;
    event_t ev_req;
    event_t ev_resp;
    mutex_t blockingstate_mutex;
    event_t blockingstate_event;
    spin_lock_t runningstate_lock;
    int cpu_expected;
    int cpu_actual;
};

/**
 * struct pincputest_t - test state structure for the pincputest
 * @is_rt_main:               If true, main thread is real-time
 * @is_rt_peer:               If true, peer thread is real-time
 * @pinned_is_current:        If true, main thread sets the peer
 *                            thread's pinned cpu to the current cpu
 * @priority_main:            Priority of the main thread
 * @priority_peer:            Priority of the peer thread
 * @expected_state_peer:      Expected thread state
 *                            (running/ready/blocked/sleeping)
 *                            for the peer thread to be in when
 *                            its cpu pinning is updated
 * @blockingstate_use_mutex:  If true, the peer thread blocks on a mutex,
 *                            If false, it blocks on an event.
 * @ctx_main:                 main thread context
 * @ctx_peer:                 peer thread context
 * The pincputest consists of a `main` thread setting cpu pinning
 * on a `peer` thread. The test covers main and peer threads
 * being standard or realtime threads and having different relative priorities.
 */
typedef struct {
    bool is_rt_main;
    bool is_rt_peer;
    bool pinned_is_current;
    int priority_main;
    int priority_peer;
    enum thread_state expected_state_peer;
    bool blockingstate_use_mutex;
    struct pincputest_thread_ctx_main ctx_main;
    struct pincputest_thread_ctx_peer ctx_peer;
} pincputest_t;

static const char* thread_state_to_str(enum thread_state state) {
    switch (state) {
    case THREAD_SUSPENDED:
        return "Suspended";
    case THREAD_READY:
        return "Ready";
    case THREAD_RUNNING:
        return "Running";
    case THREAD_BLOCKED:
        return "Blocked";
    case THREAD_SLEEPING:
        return "Sleeping";
    case THREAD_DEATH:
        return "Death";
    default:
        return "Unknown";
    }
}

static void pincputest_param_to_string(const void* param) {
    const void* const* params = param;
    TRACEF("[main:%s(%d), peer:%s(%d)]\n", *(bool*)params[0] ? "rt" : "std",
           *(int*)params[2], *(bool*)params[1] ? "rt" : "std",
           *(int*)params[3]);
}

/**
 * pincputest_unittest_thread() is the controller test function
 * invoked from the unittest thread.
 * It will ensure that the peer thread is in a given state
 * before the main thread invoked thread_set_pinned_cpu on the peer thread
 */
static void pincputest_unittest_thread(pincputest_t* _state) {
    struct pincputest_thread_ctx_main* ctx_main = &_state->ctx_main;
    struct pincputest_thread_ctx_peer* ctx_peer = &_state->ctx_peer;
    spin_lock_saved_state_t lock_state_main;
    spin_lock_saved_state_t lock_state_peer;
    ctx_main->test_state = _state;
    ctx_peer->test_state = _state;
    int cpu_peer = -1;           /* current cpu for the peer thread */
    ctx_peer->cpu_expected = -1; /* new target/pinned cpu for the peer thread */
    ctx_main->cpu_expected = -1; /* target cpu for the main thread */

    /*
     * set current thread's priority just higher from peer:
     * this thread (the unittest thread) handles the
     * necessary locking / unlocking for the peer thread
     * to reach the desired state.
     * So the unittest thread shall be either same priority
     * than peer if non real-time (with time slicing
     * / collaborative multi-threading), or higher priority
     * in case peer is a real-time thead.
     * To make things simpler, we set its priority higher
     * than the peer thread
     */
    thread_set_priority(_state->priority_peer + 1);

    for (int c = 0; c <= PINCPU_TEST_CPU_COUNT; c++) {
        /* reset actual_pinned_cpu:
         * [-1..PINCPU_TEST_CPU_COUNT-1] are all valid values
         * PINCPU_TEST_CPU_COUNT can thus be used as the reset value
         */
        ctx_main->actual_pinned_cpu = PINCPU_TEST_CPU_COUNT;
        cpu_peer = ctx_peer->cpu_actual == -1 ? 0 : ctx_peer->cpu_actual;
        if (thread_pinned_cpu(ctx_peer->thread) == -1) {
            /* this case can only happen at the beginning of the test */
            DEBUG_ASSERT(c == 0);
            thread_set_pinned_cpu(ctx_peer->thread, cpu_peer);
        }
        DEBUG_ASSERT(thread_pinned_cpu(ctx_peer->thread)== cpu_peer);

        /*
         * define the new target pinned cpu
         * for both peer and main threads
         */
        ctx_peer->cpu_expected = (cpu_peer + 1) % PINCPU_TEST_CPU_COUNT;
        if (_state->pinned_is_current) {
            ctx_main->cpu_expected = ctx_peer->cpu_expected;
        } else {
            ctx_main->cpu_expected = (cpu_peer + 2) % PINCPU_TEST_CPU_COUNT;
        }
        thread_set_pinned_cpu(ctx_main->thread, ctx_main->cpu_expected);
        if (c == PINCPU_TEST_CPU_COUNT) {
            /* for the last round, unpin peer thread */
            ctx_peer->cpu_expected = -1;
        }

        /*
         * `unittest` thread shall be pinned to same cpu
         * as `peer` thread when peer expected state is
         * ready, blocked or sleeping.
         * However if the expected state is running, the
         * unittest thread shall be pinned to another cpu
         * (another than current and new pinned target cpu)
         */
        if (_state->expected_state_peer == THREAD_RUNNING) {
            thread_set_pinned_cpu(get_current_thread(),
                                  (cpu_peer + 3) % PINCPU_TEST_CPU_COUNT);
        } else {
            thread_set_pinned_cpu(get_current_thread(), cpu_peer);
        }
        /*
         * In unit-test environment, ensure all cpus are idle before
         * starting the test. We actually want the cpu on which to pin the
         * peer thread to be idle when thread_set_pinned_cpu is invoked, as
         * this is the most complex scheduling state.
         */
        thread_sleep_ns(100000000); /* wait 100ms for tgt cpu to be idle */

        /* start the test by prepping
         * the locking states for the peer thread
         */
        if (_state->expected_state_peer == THREAD_BLOCKED &&
            _state->blockingstate_use_mutex) {
            mutex_acquire(&ctx_peer->blockingstate_mutex);
        }

        /*
         * notify the peer thread of a new test:
         * the peer thread will take the right
         * action to reach its expected state
         * before the main thread invokes
         * thread_set_pinned_cpu()
         */
        LTRACEF("ev_req sent to peer (pinned_cpu=%d curr_cpu=%d)\n",
                thread_pinned_cpu(get_current_thread()), arch_curr_cpu_num());
        event_signal(&ctx_peer->ev_req, true);

        /*
         * then notify the main thread
         * to invoke thread_set_pinned_cpu
         */
        LTRACEF("ev_req sent to main (pinned_cpu=%d curr_cpu=%d)\n",
                thread_pinned_cpu(get_current_thread()), arch_curr_cpu_num());
        event_signal(&ctx_main->ev_req, true);

        /* now wait for the main thread to invoke
         * the cpu pinning on the peer thread
         * if main thread is not supposed to be
         * preempted by the peer thread, simply
         * wait for the response event.
         * however if main thread is preempted while
         * right away (due to a higher priority peer thread)
         * peer thread needs to be unlocked as soon
         * as peer thread is pinned to new cpu and main thread
         * is in ready state
         */
        bool main_preempted = false;
        if ((ctx_peer->cpu_expected > -1) &&
            (_state->expected_state_peer == THREAD_RUNNING)) {
            if (_state->priority_main < _state->priority_peer) {
                main_preempted = true;
            }
        }
        if (main_preempted) {
            // thread_sleep_ns(1000000000);  // sleep 1sec
            volatile int* peer_cpu_ptr = &ctx_peer->cpu_actual;
            int peer_cpu;
            int busy_loop_cnt = 0;
            do {
                spin_lock_irqsave(&ctx_peer->runningstate_lock,
                                  lock_state_peer);
                peer_cpu = *peer_cpu_ptr;
                spin_unlock_irqrestore(&ctx_peer->runningstate_lock,
                                       lock_state_peer);
                if (peer_cpu != ctx_peer->cpu_expected &&
                    ++busy_loop_cnt % 10000 == 0) {
                    LTRACEF("%s: thread %s, actual_cpu [%d] != expected_cpu [%d], keep waiting...\n",
                            __func__, ctx_peer->thread->name, peer_cpu,
                            ctx_peer->cpu_expected);
                }
            } while (peer_cpu != ctx_peer->cpu_expected);

            LTRACEF("%s: thread %s, curr_cpu [%d] == expected_cpu [%d]!\n",
                    __func__, ctx_peer->thread->name, peer_cpu,
                    ctx_peer->cpu_expected);
        } else if (_state->expected_state_peer == THREAD_READY) {
            /*
             * for peer thread to be in READY state, the higher priority
             * unittest thread shall be busy on the same cpu as the peer thread
             * until the main thread is done with the pinned cpu request.
             * loop until the peer thread pinning completes.
             */
            volatile int* peer_pinned_cpu_ptr = &ctx_main->actual_pinned_cpu;
            int peer_cpu;
            // int busy_loop_cnt = 0;
            do {
                spin_lock_irqsave(&ctx_main->runningstate_lock,
                                  lock_state_main);
                peer_cpu = *peer_pinned_cpu_ptr;
                spin_unlock_irqrestore(&ctx_main->runningstate_lock,
                                       lock_state_main);
                /* note: do not add LTRACEF statement as the thread will
                 * become BLOCKED and the expected peer thread state
                 * will not be gguaranted!!
                 */
            } while (peer_cpu != ctx_peer->cpu_expected);
            LTRACEF("ev_resp from main waiting...\n");
            event_wait(&ctx_main->ev_resp);
            LTRACEF("ev_resp from main received!\n");
        } else {
            LTRACEF("ev_resp from main waiting...\n");
            event_wait(&ctx_main->ev_resp);
            LTRACEF("ev_resp from main received!\n");
        }
        /* unblock the peer thread for it
         * to complete the test
         * (report its actual cpu)
         */
        if (_state->expected_state_peer == THREAD_BLOCKED &&
            _state->blockingstate_use_mutex) {
            mutex_release(&ctx_peer->blockingstate_mutex);
        } else if (_state->expected_state_peer == THREAD_BLOCKED &&
                   !_state->blockingstate_use_mutex) {
            event_signal(&ctx_peer->blockingstate_event, true);
        }
        event_wait(&ctx_peer->ev_resp);
        if (main_preempted) {
            event_wait(&ctx_main->ev_resp);
        }
        thread_sleep_ns(100000000); /* wait 100ms for tgt cpu to be idle */
        LTRACEF("%s[%s] / %s[%s]\n", ctx_main->thread->name,
                thread_state_to_str(ctx_main->thread->state),
                ctx_peer->thread->name,
                thread_state_to_str(ctx_peer->thread->state));
        DEBUG_ASSERT(ctx_main->thread->state == THREAD_BLOCKED);
        DEBUG_ASSERT(ctx_peer->thread->state == THREAD_BLOCKED);
        if (ctx_peer->cpu_expected > -1) {
            ASSERT_EQ(ctx_peer->cpu_expected, ctx_peer->cpu_actual);
        } else {
            ASSERT_GT(ctx_peer->cpu_actual, -1);
        }
        LTRACEF("%s: cpu expected (%d) actual (%d)\n**********************\n",
                __func__, ctx_peer->cpu_expected, ctx_peer->cpu_actual);
    }
test_abort:
    thread_set_priority(HIGH_PRIORITY);
    thread_set_pinned_cpu(get_current_thread(), -1);
    ctx_main->test_state = NULL;
    ctx_peer->test_state = NULL;
}

static int pincputest_main_thread(void* _state) {
    pincputest_t* state = _state;
    struct pincputest_thread_ctx_main* ctx = &state->ctx_main;
    struct pincputest_thread_ctx_peer* ctx_peer = &state->ctx_peer;
    spin_lock_saved_state_t lock_state_main;
    while (1) {
        LTRACEF("ev_req waiting in main (pinned_cpu=%d curr_cpu=%d)\n",
                thread_pinned_cpu(get_current_thread()), arch_curr_cpu_num());
        event_wait(&ctx->ev_req);
        LTRACEF("ev_req received in main (pinned_cpu=%d curr_cpu=%d)\n",
                thread_pinned_cpu(get_current_thread()), arch_curr_cpu_num());
        DEBUG_ASSERT(_state);
        if (state->expected_state_peer == THREAD_DEATH) {
            /* exiting */
            LTRACEF("main thread exiting...\n");
            event_signal(&ctx->ev_resp, true);
            return 0;
        }
        thread_set_priority(state->priority_main);
        while (_state &&
               ctx_peer->thread->state != state->expected_state_peer) {
            thread_sleep_ns(10000000);  // sleep 10ms
            if (ctx_peer->thread->state != state->expected_state_peer) {
                LTRACEF("%s: thread %s, state [%s] != expected [%s], keep waiting...\n",
                        __func__, ctx_peer->thread->name,
                        thread_state_to_str(ctx_peer->thread->state),
                        thread_state_to_str(state->expected_state_peer));
            }
        }
        DEBUG_ASSERT(_state);
        if (ctx->cpu_expected > -1) {
            ASSERT_EQ(thread_curr_cpu(get_current_thread()), ctx->cpu_expected);
        }
        if (ctx_peer->cpu_expected == -1) {
            thread_set_pinned_cpu(get_current_thread(), -1);
        }
        thread_set_pinned_cpu(ctx_peer->thread, ctx_peer->cpu_expected);
        spin_lock_irqsave(&ctx->runningstate_lock, lock_state_main);
        ctx->actual_pinned_cpu = thread_pinned_cpu(ctx_peer->thread);
        spin_unlock_irqrestore(&ctx->runningstate_lock, lock_state_main);
        event_signal(&ctx->ev_resp, true);
        LTRACEF("ev_resp sent...\n");
        DEBUG_ASSERT(_state);
    test_abort:;
        thread_set_priority(HIGH_PRIORITY);
    }
    return 0;
}

static int pincputest_peer_thread(void* _state) {
    pincputest_t* state = _state;
    struct pincputest_thread_ctx_peer* ctx = &state->ctx_peer;
    spin_lock_saved_state_t lock_state_peer;
    int pinned_cpu;
    int curr_cpu;
    bool done;
    while (1) {
        LTRACEF("ev_req waiting in peer (pinned_cpu=%d curr_cpu=%d)\n",
                thread_pinned_cpu(get_current_thread()), arch_curr_cpu_num());
        event_wait(&ctx->ev_req);
        LTRACEF("ev_req received in peer (pinned_cpu=%d curr_cpu=%d)\n",
                thread_pinned_cpu(get_current_thread()), arch_curr_cpu_num());
        DEBUG_ASSERT(_state);
        thread_set_priority(state->priority_peer);
        switch (state->expected_state_peer) {
        case THREAD_RUNNING:
        case THREAD_READY:
            /* start busy loop */
            done = false;
            do {
                spin_lock_irqsave(&ctx->runningstate_lock, lock_state_peer);
                pinned_cpu = thread_pinned_cpu(get_current_thread());
                curr_cpu = thread_curr_cpu(get_current_thread());
                spin_unlock_irqrestore(&ctx->runningstate_lock,
                                       lock_state_peer);

                if (ctx->cpu_expected > -1) {
                    if (curr_cpu == ctx->cpu_expected) {
                        done = true;
                    }
                } else {
                    if (pinned_cpu == -1) {
                        done = true;
                    }
                }
            } while (!done);
            LTRACEF("%s: thread %s, curr_cpu [%d] == expected_cpu [%d]!\n",
                    __func__, ctx->thread->name, curr_cpu, ctx->cpu_expected);
            break;
        case THREAD_BLOCKED:
            /* go to BLOCKED state */
            if (state->blockingstate_use_mutex) {
                mutex_acquire(&ctx->blockingstate_mutex);
                mutex_release(&ctx->blockingstate_mutex);
            } else {
                event_wait(&ctx->blockingstate_event);
            }
            break;
        case THREAD_SLEEPING:
            /* go to SLEEPING state for 1 sec */
            thread_sleep_ns(1000000000);
            break;
        case THREAD_DEATH:
            /* exiting */
            LTRACEF("peer thread exiting...\n");
            event_signal(&ctx->ev_resp, true);
            return 0;
        default:
            event_signal(&ctx->ev_resp, true);
            return -1;
        }
        spin_lock_irqsave(&ctx->runningstate_lock, lock_state_peer);
        ctx->cpu_actual = thread_curr_cpu(get_current_thread());
        spin_unlock_irqrestore(&ctx->runningstate_lock, lock_state_peer);
        if (ctx->cpu_expected > -1) {
            LTRACEF("PinCpuWhenThreadState%s [%s] cpu expected (%d) actual (%d)\n",
                    thread_state_to_str(state->expected_state_peer),
                    ctx->cpu_expected == ctx->cpu_actual ? "PASSED" : "FAILED",
                    ctx->cpu_expected, ctx->cpu_actual);
        }
        event_signal(&ctx->ev_resp, true);
        thread_set_priority(HIGH_PRIORITY);
    }
    return 0;
}

static void pincputest_init_threads(pincputest_t* _state) {
    char name[24];

    /* init peer thread */
    const char* peer_name = "pincputest-peer-";
    struct pincputest_thread_ctx_peer* ctx_peer = &_state->ctx_peer;
    strlcpy(name, peer_name, sizeof(name));
    strlcat(name, _state->is_rt_peer ? "rt" : "std", sizeof(name));
    event_init(&ctx_peer->ev_req, false, EVENT_FLAG_AUTOUNSIGNAL);
    event_init(&ctx_peer->ev_resp, false, EVENT_FLAG_AUTOUNSIGNAL);
    spin_lock_init(&ctx_peer->runningstate_lock);
    mutex_init(&ctx_peer->blockingstate_mutex);
    event_init(&ctx_peer->blockingstate_event, false, EVENT_FLAG_AUTOUNSIGNAL);
    ctx_peer->thread =
            thread_create(name, pincputest_peer_thread, (void*)_state,
                          HIGH_PRIORITY, DEFAULT_STACK_SIZE);
    if (_state->is_rt_peer) {
        thread_set_real_time(ctx_peer->thread);
    }
    thread_set_pinned_cpu(ctx_peer->thread, 0);
    ctx_peer->cpu_actual = -1;

    /* init main thread */
    struct pincputest_thread_ctx_main* ctx_main = &_state->ctx_main;
    const char* main_name = "pincputest-main-";
    strlcpy(name, main_name, sizeof(name));
    strlcat(name, _state->is_rt_main ? "rt" : "std", sizeof(name));
    event_init(&ctx_main->ev_req, false, EVENT_FLAG_AUTOUNSIGNAL);
    event_init(&ctx_main->ev_resp, false, EVENT_FLAG_AUTOUNSIGNAL);
    spin_lock_init(&ctx_main->runningstate_lock);
    ctx_main->thread =
            thread_create(name, pincputest_main_thread, (void*)_state,
                          HIGH_PRIORITY, DEFAULT_STACK_SIZE);
    if (_state->is_rt_main) {
        thread_set_real_time(ctx_main->thread);
    }
    thread_resume(ctx_peer->thread);
    thread_resume(ctx_main->thread);
}

TEST_F_SETUP(pincputest) {
    const void* const* params = GetParam();
    // pincputest_param_to_string(params);
    const bool* is_rt_main = params[0];
    const bool* is_rt_peer = params[1];
    const bool* pinned_is_current = params[2];
    const int* priority_main = params[3];
    const int* priority_peer = params[4];
    _state->is_rt_main = *is_rt_main;
    _state->is_rt_peer = *is_rt_peer;
    _state->pinned_is_current = *pinned_is_current;
    _state->priority_main = *priority_main;
    _state->priority_peer = *priority_peer;
    pincputest_init_threads(_state);
}

TEST_F_TEARDOWN(pincputest) {
    int ret;
    struct pincputest_thread_ctx_main* ctx_main = &_state->ctx_main;
    struct pincputest_thread_ctx_peer* ctx_peer = &_state->ctx_peer;

    _state->expected_state_peer = THREAD_DEATH;
    /* exiting main thread */
    event_signal(&ctx_main->ev_req, true);
    event_wait(&ctx_main->ev_resp);
    thread_join(_state->ctx_main.thread, &ret, INFINITE_TIME);

    /* exiting peer thread */
    event_signal(&ctx_peer->ev_req, true);
    event_wait(&ctx_peer->ev_resp);
    thread_join(_state->ctx_peer.thread, &ret, INFINITE_TIME);

    event_destroy(&ctx_main->ev_req);
    event_destroy(&ctx_main->ev_resp);
    event_destroy(&ctx_peer->ev_req);
    event_destroy(&ctx_peer->ev_resp);
    mutex_destroy(&ctx_peer->blockingstate_mutex);
    event_destroy(&ctx_peer->blockingstate_event);
}

TEST_P(pincputest, PinCpuWhenThreadStateRunning) {
    LTRACEF("PinCpuWhenThreadStateRunning\n");
    _state->expected_state_peer = THREAD_RUNNING;
    _state->blockingstate_use_mutex = false;
    pincputest_unittest_thread(_state);
    ASSERT_EQ(HasFailure(), 0);
test_abort:;
}

TEST_P(pincputest, PinCpuWhenThreadStateReady) {
    LTRACEF("PinCpuWhenThreadStateReady\n");
    _state->expected_state_peer = THREAD_READY;
    _state->blockingstate_use_mutex = false;
    pincputest_unittest_thread(_state);
    ASSERT_EQ(HasFailure(), 0);
test_abort:;
}

TEST_P(pincputest, PinCpuWhenThreadStateSleeping) {
    LTRACEF("PinCpuWhenThreadStateSleeping\n");
    _state->expected_state_peer = THREAD_SLEEPING;
    _state->blockingstate_use_mutex = false;
    pincputest_unittest_thread(_state);
    ASSERT_EQ(HasFailure(), 0);
test_abort:;
}

TEST_P(pincputest, PinCpuWhenThreadStateBlockingOnMutex) {
    LTRACEF("PinCpuWhenThreadStateBlockingOnMutex\n");
    _state->expected_state_peer = THREAD_BLOCKED;
    _state->blockingstate_use_mutex = true;
    pincputest_unittest_thread(_state);
    ASSERT_EQ(HasFailure(), 0);
test_abort:;
}

TEST_P(pincputest, PinCpuWhenThreadStateBlockingOnEvent) {
    LTRACEF("PinCpuWhenThreadStateBlockingOnEvent\n");
    _state->expected_state_peer = THREAD_BLOCKED;
    _state->blockingstate_use_mutex = false;
    pincputest_unittest_thread(_state);
    ASSERT_EQ(HasFailure(), 0);
test_abort:;
}

INSTANTIATE_TEST_SUITE_P(
        standard_threads,
        pincputest,
        testing_Combine(/* is_main_rt: main thread is standard */
                        testing_Values(0),
                        /* is_main_rt: peer thread is standard */
                        testing_Values(0),
                        /* pinned_is_current: peer thread pinned to current */
                        testing_Bool(),
                        /* main thread priority */
                        testing_Values(HIGH_PRIORITY),
                        /* peer thread priority */
                        testing_Values(HIGH_PRIORITY,
                                       HIGH_PRIORITY + 2,
                                       HIGH_PRIORITY - 2)));

INSTANTIATE_TEST_SUITE_P(
        current_is_realtime,
        pincputest,
        testing_Combine(/* is_main_rt: main thread is standard or real-time */
                        testing_Values(1),
                        /* is_main_rt: peer thread is real-time */
                        testing_Values(0),
                        /* pinned_is_current: peer thread pinned to current */
                        testing_Values(1),  // testing_Bool(),
                        /* main thread priority */
                        testing_Values(HIGH_PRIORITY),
                        /* peer thread priority */
                        testing_Values(HIGH_PRIORITY,
                                       HIGH_PRIORITY + 2,
                                       HIGH_PRIORITY - 2)));

PORT_TEST(pincputest, "com.android.kernel.pincputest");