// Copyright(c) 2019-2020, Intel Corporation

//

// Redistribution  and  use  in source  and  binary  forms,  with  or  without

// modification, are permitted provided that the following conditions are met:

//

// * Redistributions of  source code  must retain the  above copyright notice,

//   this list of conditions and the following disclaimer.

// * Redistributions in binary form must reproduce the above copyright notice,

//   this list of conditions and the following disclaimer in the documentation

//   and/or other materials provided with the distribution.

// * Neither the name  of Intel Corporation  nor the names of its contributors

//   may be used to  endorse or promote  products derived  from this  software

//   without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO,  THE

// IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

// ARE DISCLAIMED.  IN NO EVENT  SHALL THE COPYRIGHT OWNER  OR CONTRIBUTORS BE

// LIABLE  FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL,  SPECIAL,  EXEMPLARY,  OR

// CONSEQUENTIAL  DAMAGES  (INCLUDING,  BUT  NOT LIMITED  TO,  PROCUREMENT  OF

// SUBSTITUTE GOODS OR SERVICES;  LOSS OF USE,  DATA, OR PROFITS;  OR BUSINESS

// INTERRUPTION)  HOWEVER CAUSED  AND ON ANY THEORY  OF LIABILITY,  WHETHER IN

// CONTRACT,  STRICT LIABILITY,  OR TORT  (INCLUDING NEGLIGENCE  OR OTHERWISE)

// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,  EVEN IF ADVISED OF THE

// POSSIBILITY OF SUCH DAMAGE.

#include "gtest/gtest.h"

#include "mock/test_system.h"

extern "C" {

fpga_result load_board_plugin(fpga_token token, void** dl_handle);

int unload_board_plugin(void);

int parse_mac_args(int argc, char *argv[]);

fpga_result mac_filter(fpga_properties * filter, int arc, char *argv[]);

fpga_result mac_command(fpga_token *tokens, int num_tokens, int argc, char *argv[]);

int parse_phy_args(int argc, char *argv[]);

fpga_result phy_filter(fpga_properties *filter, int argc, char *argv[]);

fpga_result phy_command(fpga_token *tokens, int num_tokens, int argc, char *argv[]);

fpga_result mac_info(fpga_token token);

fpga_result phy_group_info(fpga_token token);

}

using namespace opae::testing;

class fpgainfo_board_c_p : public ::testing::TestWithParam<std::string> {

  protected:

    fpgainfo_board_c_p() {}

    virtual void SetUp() override 

    {

        ASSERT_TRUE(test_platform::exists(GetParam()));

        platform_ = test_platform::get(GetParam());

        system_ = test_system::instance();

        system_->initialize();

        system_->prepare_syfs(platform_);

        EXPECT_EQ(fpgaInitialize(nullptr), FPGA_OK);

        optind = 0;

    }

    virtual void TearDown() override {

        fpgaFinalize();

        system_->finalize();

    }

    test_platform platform_;

    test_system *system_;

};

/**

 * @test       invalid_loading_tests

 * @brief      Test: load_board_plugin, unload_board_plugin

 * @detail:    Given invalid params to load_board_plugin,

 *                     the fn returns FPGA_INVALID_PARAM

 *                     unload_board_plugin return FPGA_OK

 */  

TEST(fpgainfo_board_c, invalid_loading_tests) {

    EXPECT_EQ(load_board_plugin(NULL, NULL), FPGA_INVALID_PARAM);

    EXPECT_EQ(unload_board_plugin(), FPGA_OK);

}

/**

 * @test       invalid_loading_tests

 * @brief      Test: load_board_plugin

 * @detail     Given valid filter and invalid token upon enumeration, 

 *             load_board_plugin returns FPGA_INVALID_PARAM

 */

TEST_P(fpgainfo_board_c_p, load_board_plugin) {

    void* dl_handle = NULL;

    fpga_properties filter = NULL;

    fpga_token tokens = NULL;

    uint32_t matches = 0;

    ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);

    ASSERT_EQ(fpgaEnumerate(&filter, 1, &tokens, 1, &matches), FPGA_OK);

    ASSERT_GT(matches, 0);

    EXPECT_EQ(load_board_plugin(&tokens, &dl_handle), FPGA_INVALID_PARAM);

    EXPECT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);

    EXPECT_EQ(fpgaDestroyToken(&tokens), FPGA_OK);

}

/**

 * @test       parse_mac_args0

 * @brief      Test: parse_mac_args

 * @details    When passed with valid command options, 

 *             the fn returns 0. For invalid options, fn returns -1. 

 */

TEST_P(fpgainfo_board_c_p, parse_mac_args0) {

    char zero[20];

    char one[20];

    char two[20];

    char *argv[] = { zero, one, two };

    strcpy(zero, "fpgainfo");

    strcpy(one, "mac");

    EXPECT_EQ(parse_mac_args(2, argv), 0);

    strcpy(two, "-h");

    EXPECT_EQ(parse_mac_args(3, argv), -1);

    strcpy(two, "-z");

    EXPECT_EQ(parse_mac_args(3, argv), -1);

}

/**

 * @test       mac_filter

 * @brief      Test: mac_filter

 * @details    When passed with invalid command options, 

 *             the fn returns FPGA_INVALID_PARAM. 

 */

TEST_P(fpgainfo_board_c_p, mac_filter) {

    char zero[20];

    char one[20];

    char *argv[] = { zero, one };

    fpga_properties filter = NULL;

    strcpy(zero, "fpgainfo");

    strcpy(one, "mac");

    EXPECT_EQ(mac_filter(&filter, 2, argv), FPGA_INVALID_PARAM);

}

/**

* @test       mac_command0

* @brief      Test: mac_command

* @details    When passed with invalid token, 

*             the fn returns FPGA_INVALID_PARAM. 

*/

TEST_P(fpgainfo_board_c_p, mac_command0) {

    char *argv[] = { };

    fpga_token tokens = NULL;

    EXPECT_EQ(mac_command(&tokens, 0, 0, argv), FPGA_OK);

}

/**

* @test       mac_command1

* @brief      Test: mac_command

* @details    When passed with valid token and fails to get properties, 

*             the fn returns FPGA_INVALID_PARAM. 

*/

TEST_P(fpgainfo_board_c_p, mac_command1) {

    char *argv[] = { };

    fpga_properties filter = NULL;

    fpga_token tokens = NULL;

    uint32_t matches = 0, num_tokens = 0;

    ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);

    ASSERT_EQ(fpgaEnumerate(&filter, 1, &tokens, 1, &matches), FPGA_OK);

    ASSERT_GT(matches, 0);

    EXPECT_EQ(mac_command(&tokens, num_tokens, 0, argv), FPGA_OK);

    EXPECT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);

    EXPECT_EQ(fpgaDestroyToken(&tokens), FPGA_OK);

}

/**

* @test       mac_info

* @brief      Test: mac_info

* @details    When passed with invalid token, 

*             the fn returns FPGA_INVALID_PARAM. 

*/

TEST_P(fpgainfo_board_c_p, mac_info) {

    fpga_token tokens = NULL;

    EXPECT_EQ(mac_info(tokens), FPGA_INVALID_PARAM);

}

/**

 * @test       parse_phy_args0

 * @brief      Test: parse_phy_args

 * @details    When passed with valid command options, 

 *             the fn returns 0. For invalid options, fn returns -1. 

 */

TEST_P(fpgainfo_board_c_p, parse_phy_args0) {

    char zero[20];

    char one[20];

    char two[20];

    char *argv[] = { zero, one, two };

    strcpy(zero, "fpgainfo");

    strcpy(one, "phy");

    EXPECT_EQ(parse_phy_args(2, argv), 0);

    strcpy(two, "-h");

    EXPECT_EQ(parse_phy_args(3, argv), -1);

    strcpy(two, "-z");

    EXPECT_EQ(parse_phy_args(3, argv), -1);

}

/**

 * @test       parse_phy_args0

 * @brief      Test: parse_phy_args

 * @details    When passed with valid command options, 

 *             the fn returns 0. 

 *             For invalid options, fn returns -1. 

 */

TEST_P(fpgainfo_board_c_p, parse_phy_args1) {

    char zero[20];

    char one[20];

    char two[20];

    char three[20];

    char *argv[] = { zero, one, two, three};

    strcpy(zero, "fpgainfo");

    strcpy(one, "phy");

    strcpy(two, "-G");

    strcpy(three, "all");

    EXPECT_EQ(parse_phy_args(4, argv), 0);

    strcpy(three, "0");

    EXPECT_EQ(parse_phy_args(4, argv), 0);

    strcpy(three, "1");

    EXPECT_EQ(parse_phy_args(4, argv), 0);

    strcpy(three, "99");

    EXPECT_EQ(parse_phy_args(4, argv), -1);

}

/**

 * @test       phy_filter

 * @brief      Test: phy_filter

 * @details    When passed with invalid command options, 

 *             the fn returns FPGA_INVALID_PARAM. 

 */

TEST_P(fpgainfo_board_c_p, phy_filter) {

    char zero[20];

    char one[20];

    char *argv[] = { zero, one };

    fpga_properties filter = NULL;

    strcpy(zero, "fpgainfo");

    strcpy(one, "phy");

    EXPECT_EQ(phy_filter(&filter, 2, argv), FPGA_INVALID_PARAM);

}

/**

* @test       phy_command0

* @brief      Test: phy_command

* @details    The phy_command fn always returen FPGA_OK 

*/

TEST_P(fpgainfo_board_c_p, phy_command0) {

    char *argv[] = { };

    fpga_token tokens = NULL;

    EXPECT_EQ(phy_command(&tokens, 0, 0, argv), FPGA_OK);

}

/**

* @test       phy_command1

* @brief      Test: phy_command

* @details    The phy_command fn always returen FPGA_OK 

*/

TEST_P(fpgainfo_board_c_p, phy_command1) {

    char *argv[] = { };

    fpga_properties filter = NULL;

    fpga_token tokens = NULL;

    uint32_t matches = 0, num_tokens = 0;

    ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);

    ASSERT_EQ(fpgaEnumerate(&filter, 1, &tokens, 1, &matches), FPGA_OK);

    ASSERT_GT(matches, 0);

    EXPECT_EQ(phy_command(&tokens, num_tokens, 0, argv), FPGA_OK);

    EXPECT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);

    EXPECT_EQ(fpgaDestroyToken(&tokens), FPGA_OK);

}

/**

* @test       phy_group_info

* @brief      Test: phy_group_info

* @details    Given an invalid option to phy_grou_info, the 

*             fn returns FPGA_INVALID_PARAM. 

*/

TEST_P(fpgainfo_board_c_p, phy_group_info) {

    fpga_token tokens = NULL;

    EXPECT_EQ(phy_group_info(tokens), FPGA_INVALID_PARAM);

}

INSTANTIATE_TEST_CASE_P(fpgainfo_c, fpgainfo_board_c_p,

                        ::testing::ValuesIn(test_platform::platforms({ "skx-p","dcp-rc","dcp-vc" })));