/*
 * FreeRTOS V202111.00
 * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  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.
 *
 * https://www.FreeRTOS.org
 * https://github.com/FreeRTOS
 *
 */
/*! @file queue_registry_utest.c */

/* C runtime includes. */
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <assert.h>

#include "../queue_utest_common.h"

/* Queue includes */
#include "FreeRTOS.h"
#include "FreeRTOSConfig.h"
#include "queue.h"

/* ============================  GLOBAL VARIABLES =========================== */

/**
 * @brief Copy of QueueRegistryItem_t from queue.c to allow clearing items between test cases.
 */
typedef struct QUEUE_REGISTRY_ITEM
{
    const char * pcQueueName;
    QueueHandle_t xHandle;
} xQueueRegistryItem;
typedef xQueueRegistryItem QueueRegistryItem_t;

/* Access the xQueueRegistry to clear between test cases */
extern PRIVILEGED_DATA QueueRegistryItem_t xQueueRegistry[ configQUEUE_REGISTRY_SIZE ];

/* ==========================  CALLBACK FUNCTIONS =========================== */

/* ============================= Unity Fixtures ============================= */

void setUp( void )
{
    commonSetUp();
    /* Clear the queue registry between test cases */
    memset( &xQueueRegistry, 0, ( configQUEUE_REGISTRY_SIZE * sizeof( QueueRegistryItem_t ) ) );
}

void tearDown( void )
{
    commonTearDown();
}

void suiteSetUp()
{
    commonSuiteSetUp();
}

int suiteTearDown( int numFailures )
{
    return commonSuiteTearDown( numFailures );
}

/* ===========================  Helper functions ============================ */

static bool helper_find_in_queue_registry( QueueHandle_t xQueue,
                                           const char * pcQueueName )
{
    for( int i = 0; i < configQUEUE_REGISTRY_SIZE; i++ )
    {
        if( ( xQueueRegistry[ i ].pcQueueName == pcQueueName ) &&
            ( xQueueRegistry[ i ].xHandle == xQueue ) )
        {
            return true;
        }
    }

    return false;
}

static bool helper_find_handle_in_queue_registry( QueueHandle_t xQueue )
{
    for( int i = 0; i < configQUEUE_REGISTRY_SIZE; i++ )
    {
        if( xQueueRegistry[ i ].xHandle == xQueue )
        {
            return true;
        }
    }

    return false;
}

/* ==============================  Test Cases =============================== */

/**
 * @brief Test vQueueAddToRegistry with a NULL QueueHandle_t
 * @details Verify that a NULL QueueHandle_t results in the string being stored
 *  to the QueueRegistry and a configASSERT failure.
 * @coverage vQueueAddToRegistry
 **/
void test_vQueueAddToRegistry_null_xQueue( void )
{
    const char * pcFakeStringPtr = ( char * ) ( BaseType_t ) getNextMonotonicTestValue();

    /* Expect a failed configASSERT when adding a NULL xQueue to the QueueRegistry */
    fakeAssertExpectFail();

    vQueueAddToRegistry( NULL, pcFakeStringPtr );
    TEST_ASSERT_TRUE( fakeAssertGetFlagAndClear() );

    TEST_ASSERT_TRUE( helper_find_in_queue_registry( NULL, pcFakeStringPtr ) );
}

/**
 * @brief Test vQueueAddToRegistry with a NULL pcQueueName
 * @details Verify that a NULL pcQueueName results in the NULL string being stored
 * in the QueueRegistry and a configASSERT failure.
 * @coverage vQueueAddToRegistry
 **/
void test_vQueueAddToRegistry_null_pcQueueName( void )
{
    QueueHandle_t xFakeHandle = ( QueueHandle_t ) ( BaseType_t ) getNextMonotonicTestValue();

    vQueueAddToRegistry( xFakeHandle, NULL );

    TEST_ASSERT_FALSE( helper_find_in_queue_registry( xFakeHandle, NULL ) );
}

/**
 * @brief Test vQueueAddToRegistry with a valid xQueue and pcQueueName
 * @details Verify that calling vQueueAddToRegistry with a valid xQueue and
 * pcQueueName stores the tuple.
 * @coverage vQueueAddToRegistry
 **/
void test_vQueueAddToRegistry_success( void )
{
    QueueHandle_t xFakeHandle = ( QueueHandle_t ) ( BaseType_t ) getNextMonotonicTestValue();
    const char * pcFakeString = ( char * ) ( BaseType_t ) getNextMonotonicTestValue();

    /* Add an item to the registry */
    vQueueAddToRegistry( xFakeHandle, pcFakeString );

    /* Verify that the value was added to the registry */
    TEST_ASSERT_TRUE( helper_find_in_queue_registry( xFakeHandle, pcFakeString ) );
}

/**
 * @brief Test vQueueAddToRegistry with the same QueueHandle_t twice
 * @details Verify that a given QueueHandle_t can be added to the queue registry
 * multiple times and that the l
 * @coverage vQueueAddToRegistry
 **/
void test_vQueueAddToRegistry_twice( void )
{
    QueueHandle_t xFakeHandle = ( QueueHandle_t ) ( BaseType_t ) getNextMonotonicTestValue();
    const char * pcFakeString1 = ( char * ) ( BaseType_t ) getNextMonotonicTestValue();
    const char * pcFakeString2 = ( char * ) ( BaseType_t ) getNextMonotonicTestValue();

    /* Add an item to the registry */
    vQueueAddToRegistry( xFakeHandle, pcFakeString1 );

    TEST_ASSERT_TRUE( helper_find_in_queue_registry( xFakeHandle, pcFakeString1 ) );

    vQueueAddToRegistry( xFakeHandle, pcFakeString2 );

    /* Verify that pcFakeString2 is now in the queue registry */
    TEST_ASSERT_TRUE( helper_find_in_queue_registry( xFakeHandle, pcFakeString2 ) );

    /* Verify that pcFakeString1 is no longer in the queue registry */
    TEST_ASSERT_FALSE( helper_find_in_queue_registry( xFakeHandle, pcFakeString1 ) );

    vQueueUnregisterQueue( xFakeHandle );

    /* Verify that pcFakeString2 has been removed from the registry */
    TEST_ASSERT_FALSE( helper_find_in_queue_registry( xFakeHandle, pcFakeString2 ) );
}

/**
 * @brief Test vQueueAddToRegistry with a queue registry that is already full.
 * @details Verify that a call to vQueueAddToRegistry with a full queue registry
 * fails silently.
 * @coverage vQueueAddToRegistry
 **/
void test_vQueueAddToRegistry_full( void )
{
    TEST_ASSERT_TRUE( configQUEUE_REGISTRY_SIZE < UINT32_MAX );

    /* Fill the queue registry and verify that the max items were successfully stored.
     * Start at i=1 since a NULL / 0 pcQueueName denotes an empty queue registry location */
    for( BaseType_t i = 1; i <= configQUEUE_REGISTRY_SIZE; i++ )
    {
        QueueHandle_t fakeHandle = ( QueueHandle_t ) i;
        const char * fakeString = ( char * ) i;

        /* Add our fake QueueHandle_t and const char* to the registry */
        vQueueAddToRegistry( fakeHandle, fakeString );

        /* Verify that the fake queue handle was added to the registry */
        TEST_ASSERT_EQUAL( pcQueueGetName( fakeHandle ), fakeString );
    }

    /* Prepare one more fake item to add to the registry */
    QueueHandle_t fakeHandle = ( QueueHandle_t ) ( configQUEUE_REGISTRY_SIZE + 1 );
    const char * fakeString = ( char * ) ( configQUEUE_REGISTRY_SIZE + 1 );

    /* Add one more item */
    vQueueAddToRegistry( fakeHandle, fakeString );

    TEST_ASSERT_FALSE( helper_find_in_queue_registry( fakeHandle, fakeString ) );
}

/**
 * @brief Test pcQueueGetName with a NULL QueueHandle_t
 * @details Verify that a NULL QueueHandle_t can be used as a lookup value with
 * pcQueueGetName, but causes a failed configASSERT.
 * @coverage pcQueueGetName
 **/
void test_pcQueueGetName_null_xQueue( void )
{
    const char * pcFakeString = ( char * ) ( BaseType_t ) getNextMonotonicTestValue();

    /* Expect a failed configASSERT when adding a NULL xQueue to the QueueRegistry */
    fakeAssertExpectFail();

    vQueueAddToRegistry( NULL, pcFakeString );
    fakeAssertGetFlagAndClear();

    TEST_ASSERT_TRUE( helper_find_in_queue_registry( NULL, pcFakeString ) );

    /* Expect a failed configASSERT when pcQueueGetName with a NULL xQueue */
    fakeAssertExpectFail();

    /* Validate the value returned by pcQueueGetName */
    TEST_ASSERT_EQUAL( pcQueueGetName( NULL ), pcFakeString );
    TEST_ASSERT_TRUE( fakeAssertGetFlagAndClear() );
}

/**
 * @brief Test pcQueueGetName with an xQueue handle that was not registered.
 * @details Verify that a call to pcQueueGetName with an unregistered xQueue
 * returns a NULL pointer.
 * @coverage pcQueueGetName
 **/
void test_pcQueueGetName_not_registered( void )
{
    QueueHandle_t xFakeHandle = ( QueueHandle_t ) ( BaseType_t ) getNextMonotonicTestValue();
    const char * pcFakeString = ( char * ) ( BaseType_t ) getNextMonotonicTestValue();

    /* Add an item to the registry */
    vQueueAddToRegistry( xFakeHandle, pcFakeString );

    /* Verify the value returned by pcQueueGetName matches the value added to the registry */
    TEST_ASSERT_EQUAL( pcQueueGetName( xFakeHandle ), pcFakeString );

    vQueueUnregisterQueue( xFakeHandle );

    /* Verify the value returned by pcQueueGetName matches the value added to the registry */
    TEST_ASSERT_EQUAL( NULL, pcQueueGetName( xFakeHandle ) );
}

/**
 * @brief Test pcQueueGetName with an xQueue handle that was previously registered.
 * @details Verify that a call to pcQueueGetName with a registered xQueue handle
 * returns the correct pointer
 * @coverage pcQueueGetName
 **/
void test_pcQueueGetName_registered( void )
{
    QueueHandle_t xFakeHandle = ( QueueHandle_t ) ( BaseType_t ) getNextMonotonicTestValue();
    const char * pcFakeString = ( char * ) ( BaseType_t ) getNextMonotonicTestValue();

    /* Add an item to the registry */
    vQueueAddToRegistry( xFakeHandle, pcFakeString );

    /* Verify the value returned by pcQueueGetName matches the value added to the registry */
    TEST_ASSERT_EQUAL( pcQueueGetName( xFakeHandle ), pcFakeString );
}

/**
 * @brief Test vQueueUnregisterQueue with a NULL xQueue handle
 * @details Verify that calling vQueueUnregisterQueue with a NULL xQueue results
 * in a configASSERT failure.
 * @coverage vQueueUnregisterQueue
 **/
void test_vQueueUnregisterQueue_null_handle( void )
{
    fakeAssertExpectFail();

    vQueueUnregisterQueue( NULL );

    TEST_ASSERT_TRUE( fakeAssertGetFlagAndClear() );
}

/**
 * @brief Test vQueueUnregisterQueue with an unregistered xQueue handle
 * @details Verify that calling vQueueUnregisterQueue does not result in an assertion.
 * @coverage vQueueUnregisterQueue
 **/
void test_vQueueUnregisterQueue_queue_not_registered( void )
{
    QueueHandle_t xFakeHandle = ( QueueHandle_t ) ( BaseType_t ) getNextMonotonicTestValue();

    vQueueUnregisterQueue( xFakeHandle );
}

/**
 * @brief Test vQueueUnregisterQueue on a registered xQueue
 * @details Verify that calling vQueueUnregisterQueue with a registered xQueue
 * removes the xQueue from the Queue Registry and does not result in a
 * configASSERT failure.
 * @coverage vQueueUnregisterQueue
 **/
void test_vQueueUnregisterQueue( void )
{
    QueueHandle_t xFakeHandle = ( QueueHandle_t ) ( BaseType_t ) getNextMonotonicTestValue();
    const char * pcFakeString = ( char * ) ( BaseType_t ) getNextMonotonicTestValue();

    /* Add an item to the registry */
    vQueueAddToRegistry( xFakeHandle, pcFakeString );

    TEST_ASSERT_TRUE( helper_find_handle_in_queue_registry( xFakeHandle ) );
    TEST_ASSERT_EQUAL( pcFakeString, pcQueueGetName( xFakeHandle ) );

    vQueueUnregisterQueue( xFakeHandle );

    TEST_ASSERT_FALSE( helper_find_handle_in_queue_registry( xFakeHandle ) );
}

/**
 * @brief Test two subsequent calls to vQueueUnregisterQueue on a registered xQueue
 * @details Verify that calling vQueueUnregisterQueue twice on a registered xQueue
 * succeeds the first time and results in no change on the second call.
 * @coverage vQueueUnregisterQueue
 **/
void test_vQueueUnregisterQueue_twice( void )
{
    QueueHandle_t xFakeHandle = ( QueueHandle_t ) ( BaseType_t ) getNextMonotonicTestValue();
    const char * pcFakeString = ( char * ) ( BaseType_t ) getNextMonotonicTestValue();

    /* Add an item to the registry */
    vQueueAddToRegistry( xFakeHandle, pcFakeString );

    /* Verify that the value was added to the registry */
    TEST_ASSERT_TRUE( helper_find_handle_in_queue_registry( xFakeHandle ) );

    vQueueUnregisterQueue( xFakeHandle );

    TEST_ASSERT_FALSE( helper_find_handle_in_queue_registry( xFakeHandle ) );

    vQueueUnregisterQueue( xFakeHandle );

    TEST_ASSERT_FALSE( helper_find_handle_in_queue_registry( xFakeHandle ) );
}

/**
 * @brief Test that vQueueDelete removes the xQueue from the Queue Registry
 * @details Verify that vQueueDelete removes a queue from the Queue Registry
 *  by calling vQueueUnregisterQueue.
 * @coverage vQueueDelete vQueueUnregisterQueue
 **/
void test_vQueueDelete_vQueueUnregisterQueue( void )
{
    QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) );
    const char * xQueueName = "Testing 123";

    /* Add the queue to the registry */
    vQueueAddToRegistry( xQueue, xQueueName );

    /* Verify the value returned by pcQueueGetName matches the value added to the registry */
    TEST_ASSERT_EQUAL( xQueueName, pcQueueGetName( xQueue ) );

    vQueueDelete( xQueue );

    /* Verify the value returned by pcQueueGetName is now NULL */
    TEST_ASSERT_EQUAL( NULL, pcQueueGetName( xQueue ) );
}