/*
 * Amazon FreeRTOS CBOR Library V1.0.1
 * Copyright (C) 2018 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.
 *
 * http://aws.amazon.com/freertos
 * http://www.FreeRTOS.org
 */
#include "assert_override.h"
#include "aws_cbor_internals.h"
#include "unity_fixture.h"
#include <string.h>

static CBORHandle_t xCborData;

extern int lTEST_assert_fails;

TEST_GROUP( aws_cbor_int );
TEST_SETUP( aws_cbor_int )
{
    lTEST_assert_fails = 0;
    xCborData = CBOR_New( 0 );
    uint8_t ucInit[ 32 ] = { 0 };

    CBOR_MemCopy( xCborData, ucInit, sizeof( ucInit ) );
    CBOR_SetCursor( xCborData, 0 );
}

TEST_TEAR_DOWN( aws_cbor_int )
{
    TEST_ASSERT_EQUAL( eCborErrNoError, xCborData->xError );
    TEST_ASSERT_EQUAL( 0, lTEST_assert_fails );
    CBOR_Delete( &xCborData );
}

TEST_GROUP_RUNNER( aws_cbor_int )
{
    RUN_TEST_CASE( aws_cbor_int, IntSize_SmallInt );
    RUN_TEST_CASE( aws_cbor_int, IntSize_Int8 );
    RUN_TEST_CASE( aws_cbor_int, IntSize_Int16 );
    RUN_TEST_CASE( aws_cbor_int, IntSize_Int32 );

    RUN_TEST_CASE( aws_cbor_int, WriteSmallInt );
    RUN_TEST_CASE( aws_cbor_int, WriteInt8 );
    RUN_TEST_CASE( aws_cbor_int, WriteInt16 );
    RUN_TEST_CASE( aws_cbor_int, WriteInt32 );

    RUN_TEST_CASE( aws_cbor_int, ReadSmallPositiveInt );
    RUN_TEST_CASE( aws_cbor_int, ReadPositiveInt8 );
    RUN_TEST_CASE( aws_cbor_int, ReadPositiveInt16 );
    RUN_TEST_CASE( aws_cbor_int, ReadPositiveInt32 );

    RUN_TEST_CASE( aws_cbor_int, WriteInt );

    RUN_TEST_CASE( aws_cbor_int, ReadInt );

    RUN_TEST_CASE( aws_cbor_int, ReadInt_sets_error_if_wrong_type );

    RUN_TEST_CASE( aws_cbor_int, null_checks );
}

TEST( aws_cbor_int, IntSize_SmallInt )
{
    int lNum = 12;

    CBOR_WriteInt( xCborData, &lNum );
    CBOR_SetCursor( xCborData, 0 );
    int lResult = CBOR_IntSize( xCborData->pxCursor );
    TEST_ASSERT_EQUAL( 1, lResult );
}

TEST( aws_cbor_int, IntSize_Int8 )
{
    int lNum = 42;

    CBOR_WriteInt( xCborData, &lNum );
    CBOR_SetCursor( xCborData, 0 );
    int lResult = CBOR_IntSize( xCborData->pxCursor );
    TEST_ASSERT_EQUAL( 2, lResult );
}

TEST( aws_cbor_int, IntSize_Int16 )
{
    int lNum = 1234;

    CBOR_WriteInt( xCborData, &lNum );
    CBOR_SetCursor( xCborData, 0 );
    int lResult = CBOR_IntSize( xCborData->pxCursor );
    TEST_ASSERT_EQUAL( 3, lResult );
}

TEST( aws_cbor_int, IntSize_Int32 )
{
    int lNum = INT32_MAX;

    CBOR_WriteInt( xCborData, &lNum );
    CBOR_SetCursor( xCborData, 0 );
    int lResult = CBOR_IntSize( xCborData->pxCursor );
    TEST_ASSERT_EQUAL( 5, lResult );
}

TEST( aws_cbor_int, WriteSmallInt )
{
    int lExpected = 23;

    CBOR_WriteSmallInt( xCborData, lExpected );
    TEST_ASSERT_EQUAL_INT8( lExpected, *xCborData->pxBufferStart );
}

TEST( aws_cbor_int, WriteInt8 )
{
    CBOR_WriteInt8( xCborData, 0x21 );
    uint8_t ucExpected[] = { CBOR_INT8_FOLLOWS, 0x21 };
    TEST_ASSERT_EQUAL_HEX8_ARRAY(
        ucExpected, xCborData->pxBufferStart, sizeof( ucExpected ) );
}

TEST( aws_cbor_int, WriteInt16 )
{
    CBOR_WriteInt16( xCborData, 0x1221 );
    uint8_t ucExpected[] = { CBOR_INT16_FOLLOWS, 0x12, 0x21 };
    TEST_ASSERT_EQUAL_HEX8_ARRAY(
        ucExpected, xCborData->pxBufferStart, sizeof( ucExpected ) );
}

TEST( aws_cbor_int, WriteInt32 )
{
    CBOR_WriteInt32( xCborData, 0xBA5EBA11 );
    uint8_t ucExpected[] = { CBOR_INT32_FOLLOWS, 0xBA, 0x5E, 0xBA, 0x11 };
    TEST_ASSERT_EQUAL_HEX8_ARRAY(
        ucExpected, xCborData->pxBufferStart, sizeof( ucExpected ) );
}

TEST( aws_cbor_int, ReadSmallPositiveInt )
{
    uint8_t ucInit[] =
    {
        19,
    };

    CBOR_MemCopy( xCborData, ucInit, sizeof( ucInit ) );
    CBOR_SetCursor( xCborData, 0 );
    int lResult = CBOR_ReadSmallPositiveInt( xCborData );
    int lExpected = 19;
    TEST_ASSERT_EQUAL( lExpected, lResult );
}

TEST( aws_cbor_int, ReadPositiveInt8 )
{
    uint8_t ucInit[] =
    {
        CBOR_INT8_FOLLOWS,
        42,
    };

    CBOR_MemCopy( xCborData, ucInit, sizeof( ucInit ) );
    CBOR_SetCursor( xCborData, 0 );
    int lResult = CBOR_ReadPositiveInt8( xCborData );
    int lExpected = 42;
    TEST_ASSERT_EQUAL( lExpected, lResult );
}

TEST( aws_cbor_int, ReadPositiveInt16 )
{
    uint8_t ucInit[] =
    {
        CBOR_INT16_FOLLOWS,
        0x01,
        0x02,
    };

    CBOR_MemCopy( xCborData, ucInit, sizeof( ucInit ) );
    CBOR_SetCursor( xCborData, 0 );
    int lResult = CBOR_ReadPositiveInt16( xCborData );
    int lExpected = 258;
    TEST_ASSERT_EQUAL( lExpected, lResult );
}

TEST( aws_cbor_int, ReadPositiveInt32 )
{
    uint8_t ucInit[] =
    {
        CBOR_INT16_FOLLOWS,
        0x01,
        0x02,
        0x03,
        0x04,
    };

    CBOR_MemCopy( xCborData, ucInit, sizeof( ucInit ) );
    CBOR_SetCursor( xCborData, 0 );
    int lResult = CBOR_ReadPositiveInt32( xCborData );
    int lExpected = 16909060;
    TEST_ASSERT_EQUAL( lExpected, lResult );
}

typedef struct write_test_s
{
    char * pcMessage;
    int lInput;
    uint8_t ucExpected[ 32 ];
} write_test_t;

write_test_t xWriteTests[] =
{
    {
        .pcMessage = "write small int",
        .lInput = 8,
        .ucExpected ={ 8                   },
    },
    {
        .pcMessage = "write 8 bit int",
        .lInput = 56,
        .ucExpected ={ CBOR_INT8_FOLLOWS, 56 },
    },
    {
        .pcMessage = "write 16 bit int",
        .lInput = 0x11FE,
        .ucExpected ={ CBOR_INT16_FOLLOWS, 0x11, 0xFE },
    },
    {
        .pcMessage = "write 32 bit int",
        .lInput = 0x1337C0DE,
        .ucExpected ={ CBOR_INT32_FOLLOWS, 0x13, 0x37, 0xC0, 0xDE },
    },
    {
        .pcMessage = "write largest small positive int",
        .lInput = 23,
        .ucExpected ={ 23                  },
    },
    {
        .pcMessage = "write smallest 8-bit int",
        .lInput = 24,
        .ucExpected ={ CBOR_INT8_FOLLOWS, 24 },
    },
    {
        .pcMessage = "write largest 8-bit int",
        .lInput = 255,
        .ucExpected ={ CBOR_INT8_FOLLOWS, 255 },
    },
    {
        .pcMessage = "write smallest 16-bit int",
        .lInput = 256,
        .ucExpected ={ CBOR_INT16_FOLLOWS, 0x01, 0x00 },
    },
    {
        .pcMessage = "write largest 16-bit int",
        .lInput = 0xFFFF,
        .ucExpected ={ CBOR_INT16_FOLLOWS, 0xFF, 0xFF },
    },
    {
        .pcMessage = "write smallest 32-bit int",
        .lInput = 0x010000,
        .ucExpected =
        {
            CBOR_INT32_FOLLOWS,
            0x00,
            0x01,
            0x00,
            0x00,
        },
    },
    {
        .pcMessage = "write largest positive signed 32-bit int",
        .lInput = INT32_MAX,
        .ucExpected =
        {
            CBOR_INT32_FOLLOWS,
            0x7F,
            0xFF,
            0xFF,
            0xFF,
        },
    },
};

int lWriteTestCount = ( sizeof( xWriteTests ) / sizeof( xWriteTests[ 0 ] ) );

write_test_t * pxWriteTest;

void test_WriteInt( void )
{
    CBOR_SetCursor( xCborData, 0 );
    uint8_t ucInit[ 32 ] = { 0 };
    CBOR_MemCopy( xCborData, ucInit, sizeof( ucInit ) );
    CBOR_SetCursor( xCborData, 0 );

    CBOR_WriteInt( xCborData, &pxWriteTest->lInput );
    TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE(
        pxWriteTest->ucExpected, xCborData->pxBufferStart, 32, pxWriteTest->pcMessage );
}

TEST( aws_cbor_int, WriteInt )
{
    for( int i = 0; i < lWriteTestCount; i++ )
    {
        pxWriteTest = &xWriteTests[ i ];
        RUN_TEST( test_WriteInt );
    }
}

typedef struct read_test_s
{
    char * pcMessage;
    uint8_t ucBuffer[ 32 ];
    int lExpected;
} read_test_t;

read_test_t xReadTests[] =
{
    {
        .pcMessage = "read small int",
        .ucBuffer ={ 13                 },
        .lExpected = 13,
    },
    {
        .pcMessage = "read 8-bit int",
        .ucBuffer ={ CBOR_INT8_FOLLOWS, 78 },
        .lExpected = 78,
    },
    {
        .pcMessage = "read 16-bit int",
        .ucBuffer ={ CBOR_INT16_FOLLOWS, 0x12, 0x34 },
        .lExpected = 0x1234,
    },
    {
        .pcMessage = "read 32-bit int",
        .ucBuffer ={ CBOR_INT32_FOLLOWS, 0x09, 0x87, 0x65, 0x43 },
        .lExpected = 0x09876543,
    },
    {
        .pcMessage = "read largest small positive int",
        .lExpected = 23,
        .ucBuffer ={ 23                 },
    },
    {
        .pcMessage = "read smallest 8-bit int",
        .lExpected = 24,
        .ucBuffer ={ CBOR_INT8_FOLLOWS, 24 },
    },
    {
        .pcMessage = "read largest 8-bit int",
        .lExpected = 255,
        .ucBuffer ={ CBOR_INT8_FOLLOWS, 255 },
    },
    {
        .pcMessage = "read smallest 16-bit int",
        .lExpected = 256,
        .ucBuffer ={ CBOR_INT16_FOLLOWS, 0x01, 0x00 },
    },
    {
        .pcMessage = "read largest 16-bit int",
        .lExpected = 0xFFFF,
        .ucBuffer ={ CBOR_INT16_FOLLOWS, 0xFF, 0xFF },
    },
    {
        .pcMessage = "read smallest 32-bit int",
        .lExpected = 0x010000,
        .ucBuffer =
        {
            CBOR_INT32_FOLLOWS,
            0x00,
            0x01,
            0x00,
            0x00,
        },
    },
    {
        .pcMessage = "read largest positive signed 32-bit int",
        .lExpected = INT32_MAX,
        .ucBuffer =
        {
            CBOR_INT32_FOLLOWS,
            0x7F,
            0xFF,
            0xFF,
            0xFF,
        },
    },
};

int lReadTestCount = ( sizeof( xReadTests ) / sizeof( xReadTests[ 0 ] ) );

read_test_t * pxReadTest;

void test_ReadInt( void )
{
    CBOR_SetCursor( xCborData, 0 );
    CBOR_MemCopy( xCborData, pxReadTest->ucBuffer, sizeof( pxReadTest->ucBuffer ) );
    CBOR_SetCursor( xCborData, 0 );

    int lResult = CBOR_ReadInt( xCborData );
    TEST_ASSERT_EQUAL_MESSAGE( pxReadTest->lExpected, lResult, pxReadTest->pcMessage );
}

TEST( aws_cbor_int, ReadInt )
{
    for( int i = 0; i < lReadTestCount; i++ )
    {
        pxReadTest = &xReadTests[ i ];
        RUN_TEST( test_ReadInt );
    }
}

TEST( aws_cbor_int, ReadInt_sets_error_if_wrong_type )
{
    CBOR_AssignAndIncrementCursor( xCborData, 0xFF );
    CBOR_SetCursor( xCborData, 0 );
    ( void ) CBOR_ReadInt( xCborData );
    TEST_ASSERT_EQUAL( eCborErrReadTypeMismatch, xCborData->xError );
    xCborData->xError = eCborErrNoError;
}

TEST( aws_cbor_int, null_checks )
{
    uint8_t ucFoo[] = { CBOR_INT8_FOLLOWS, 42 };

    xTEST_expect_assert( CBOR_IntSize( NULL ) );

    xTEST_expect_assert( CBOR_WriteInt( NULL, ucFoo ) );
    xTEST_expect_assert( CBOR_WriteInt( xCborData, NULL ) );

    xTEST_expect_assert( CBOR_WriteInt32( NULL, 0 ) );
    xTEST_expect_assert( CBOR_WriteInt16( NULL, 0 ) );
    xTEST_expect_assert( CBOR_WriteInt8( NULL, 0 ) );
    xTEST_expect_assert( CBOR_WriteSmallInt( NULL, 0 ) );

    xTEST_expect_assert( CBOR_ReadInt( NULL ) );

    xTEST_expect_assert( CBOR_ReadPositiveInt32( NULL ) );
    xTEST_expect_assert( CBOR_ReadPositiveInt16( NULL ) );
    xTEST_expect_assert( CBOR_ReadPositiveInt8( NULL ) );
    xTEST_expect_assert( CBOR_ReadSmallPositiveInt( NULL ) );
}