/*
 * Copyright 2023 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#include "pldm-oem-google.h"

#include "gtest/gtest.h"

class PlatformOEMGoogleDecodeEventMessageReqTest : public ::testing::Test
{
  protected:
    // Set up any necessary resources before running each test.
    void SetUp() override
    {
        // Initialize any resources here if needed.
    }

    // Clean up any allocated resources after running each test.
    void TearDown() override
    {
        // Clean up any resources here if needed.
    }
};

// Define test cases.
TEST_F(PlatformOEMGoogleDecodeEventMessageReqTest, NullEventData)
{
    // When event_data is null, the function should return
    // PLDM_EVENT_OEM_GOOGLE_ID_UNDEFINED.
    uint16_t result = platform_oem_google_decode_event_message_req(
        nullptr, 0, nullptr, nullptr);
    EXPECT_EQ(result, PLDM_EVENT_OEM_GOOGLE_ID_UNDEFINED);
}

TEST_F(PlatformOEMGoogleDecodeEventMessageReqTest, ShortEventData)
{
    // When event_data is too short, the function should return
    // PLDM_EVENT_OEM_GOOGLE_ID_UNDEFINED.
    uint8_t event_data[2] = {0x00, 0x01}; // Example short event data.
    size_t event_data_length = sizeof(event_data);
    uint16_t result = platform_oem_google_decode_event_message_req(
        event_data, event_data_length, nullptr, nullptr);
    EXPECT_EQ(result, PLDM_EVENT_OEM_GOOGLE_ID_UNDEFINED);
}

TEST_F(PlatformOEMGoogleDecodeEventMessageReqTest, InValidIANA)
{
    // Create valid event data and check the function's behavior.
    struct pldm_event_oem_google_event_hdr header
    {
        {0x01, 0x02, 0x03}, // invalid google IANA
            0x1234,         // googleOEMEventID any uint16_t value
    };

    uint8_t event_data[sizeof(header) * 2];
    memcpy(event_data, &header, sizeof(header));
    size_t event_data_length = sizeof(event_data);

    size_t oem_event_data_offset = 0;
    size_t oem_event_data_len = 0;

    uint16_t result = platform_oem_google_decode_event_message_req(
        event_data, event_data_length, &oem_event_data_offset,
        &oem_event_data_len);

    EXPECT_EQ(result, PLDM_EVENT_OEM_GOOGLE_ID_UNDEFINED);
    // oem_event_data_offset and oem_even_data_len intact
    EXPECT_EQ(oem_event_data_offset, 0);
    EXPECT_EQ(oem_event_data_len, 0);
}

TEST_F(PlatformOEMGoogleDecodeEventMessageReqTest, InValidIANAEndian)
{
    // Create valid event data and check the function's behavior.
    struct pldm_event_oem_google_event_hdr header
    {
        {0xDE, 0xD4, 0x00}, // google IANA in little endian
            0x1234,         // googleOEMEventID any uint16_t value
    };

    uint8_t event_data[sizeof(header) * 2];
    memcpy(event_data, &header, sizeof(header));
    size_t event_data_length = sizeof(event_data);

    size_t oem_event_data_offset = 0;
    size_t oem_event_data_len = 0;

    uint16_t result = platform_oem_google_decode_event_message_req(
        event_data, event_data_length, &oem_event_data_offset,
        &oem_event_data_len);

    EXPECT_EQ(result, PLDM_EVENT_OEM_GOOGLE_ID_UNDEFINED);
    // oem_event_data_offset and oem_even_data_len intact
    EXPECT_EQ(oem_event_data_offset, 0);
    EXPECT_EQ(oem_event_data_len, 0);
}

TEST_F(PlatformOEMGoogleDecodeEventMessageReqTest, ValidEventData)
{
    // Create valid event data and check the function's behavior.
    struct pldm_event_oem_google_event_hdr header
    {
        {0x00, 0xD4, 0xDE}, // google IANA
            0x1234,         // googleOEMEventID any uint16_t value
    };

    uint8_t event_data[sizeof(header) * 2];
    uint8_t oem_event_data[sizeof(header)];
    memset(event_data, 0xDD, sizeof(event_data));
    memcpy(event_data, &header, sizeof(header));
    memcpy(oem_event_data, event_data + sizeof(header), sizeof(header));
    size_t event_data_length = sizeof(event_data);

    size_t oem_event_data_offset = 0;
    size_t oem_event_data_len = 0;

    uint16_t result = platform_oem_google_decode_event_message_req(
        event_data, event_data_length, &oem_event_data_offset,
        &oem_event_data_len);

    EXPECT_EQ(result, header.googleOEMEventID);
    EXPECT_EQ(oem_event_data_offset, sizeof(header));
    EXPECT_EQ(oem_event_data_len, sizeof(header));
    EXPECT_EQ(memcmp(event_data + oem_event_data_offset, oem_event_data,
                     oem_event_data_len),
              0);
}
class PLDMEventOEMGoogleSOCResetMETest : public ::testing::Test
{};

TEST_F(PLDMEventOEMGoogleSOCResetMETest, NullOEMEventData)
{
    // When oem_event_data is null, the function should return nullptr.
    const uint8_t* oem_event_data = nullptr;
    size_t oem_event_data_len = 0;
    const struct pldm_event_oem_google_soc_reset_me* result =
        pldm_event_oem_google_soc_reset_me_msg(oem_event_data,
                                               oem_event_data_len);
    EXPECT_EQ(result, nullptr);
}

TEST_F(PLDMEventOEMGoogleSOCResetMETest, ShortOEMEventData)
{
    // When oem_event_data is too short, the function should return nullptr.
    uint8_t
        oem_event_data[sizeof(struct pldm_event_oem_google_soc_reset_me) - 1];
    size_t oem_event_data_len = sizeof(oem_event_data);
    memset(oem_event_data, 0, sizeof(oem_event_data));
    const struct pldm_event_oem_google_soc_reset_me* result =
        pldm_event_oem_google_soc_reset_me_msg(oem_event_data,
                                               oem_event_data_len);
    EXPECT_EQ(result, nullptr);
}

TEST_F(PLDMEventOEMGoogleSOCResetMETest, ValidOEMEventData)
{
    // Create valid oem_event_data and check the function's behavior.
    struct pldm_event_oem_google_soc_reset_me data;
    // Initialize data with valid values here.
    memset(&data, 0, sizeof(data));

    const uint8_t* oem_event_data = reinterpret_cast<const uint8_t*>(&data);
    size_t oem_event_data_len = sizeof(data);
    EXPECT_EQ(oem_event_data_len, 16);
    const struct pldm_event_oem_google_soc_reset_me* result =
        pldm_event_oem_google_soc_reset_me_msg(oem_event_data,
                                               oem_event_data_len);
    EXPECT_EQ(result, &data);
}

TEST_F(PLDMEventOEMGoogleSOCResetMETest, InvalidDescLen)
{
    // Create oem_event_data with an invalid descLen value.
    struct pldm_event_oem_google_soc_reset_me data;
    // Initialize data with valid values here.
    data.descLen = sizeof(struct pldm_event_oem_google_soc_reset_me) +
                   1; // Invalid descLen

    const uint8_t* oem_event_data = reinterpret_cast<const uint8_t*>(&data);
    size_t oem_event_data_len = sizeof(data);

    const struct pldm_event_oem_google_soc_reset_me* result =
        pldm_event_oem_google_soc_reset_me_msg(oem_event_data,
                                               oem_event_data_len);
    EXPECT_EQ(result, nullptr);
}