// Copyright(c) 2019, 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 <opae/fpga.h>

extern "C" {

int set_properties_from_args(fpga_properties filter, fpga_result *result,

                             int *argc, char *argv[]);

}

#include "gtest/gtest.h"

#include "mock/test_system.h"

using namespace opae::testing;

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

    protected:

        argsfilter_c_p() {}

        virtual void SetUp() override 

        {

            std::string platform_key = GetParam();

            ASSERT_TRUE(test_platform::exists(platform_key));

            platform_ = test_platform::get(platform_key);

            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       bdf

 * @brief      Test: set_properties_from_args

 * @details    When passed with valid arguments for bdf, the function 

 *             returns 0. 

 */

TEST_P(argsfilter_c_p, bdf) {

    char zero[20];

    char one[20];

    char two[20];

    char three[20];

    char four[20];

    char five[20];

    char six[20];

    char seven[20];

    char eight[20];

    char nine[20];

    char ten[20];

    char eleven[20];

    char *argv[] = { zero, one, two, three, four, five,

                     six, seven, eight, nine, ten, eleven };

    int argc = 12;

    fpga_result result;

    char bus[10];

    char device[10];

    char function[10];

    char socket_id[10];

    char segment[10];

    sprintf(bus, "0x%x", platform_.devices[0].bus);

    sprintf(device, "0x%x", platform_.devices[0].device);

    sprintf(function, "0x%x", platform_.devices[0].function);

    sprintf(socket_id, "0x%x", platform_.devices[0].socket_id);

    sprintf(segment, "0x%x", platform_.devices[0].segment);

    fpga_properties filter = NULL;

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

    strcpy(zero, "fpgainfo");

    strcpy(one, "fme");

    strcpy(two, "-B");

    strcpy(three, bus);

    strcpy(four, "-D");

    strcpy(five, device);

    strcpy(six, "-F");

    strcpy(seven, function);

    strcpy(eight, "-S");

    strcpy(nine, socket_id);

    strcpy(ten, "--segment");

    strcpy(eleven, segment);

    EXPECT_EQ(set_properties_from_args(filter, &result, &argc, argv), 0);

    EXPECT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);

    EXPECT_EQ(result, 0);

}

/**

 * @test       bus

 * @brief      Test: set_properties_from_args

 * @details    When passed with valid argument for the bus, 

 *             the function returns 0. 

 */

TEST_P(argsfilter_c_p, bus) {

    char zero[20];

    char one[20];

    char two[20];

    char three[20];

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

    int argc = 4;

    fpga_result result;

    char bus[10];

    sprintf(bus, "0x%x", platform_.devices[0].bus);

    fpga_properties filter = NULL;

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

    strcpy(zero, "fpgainfo");

    strcpy(one, "fme");

    strcpy(two, "-B");

    strcpy(three, bus);

    EXPECT_EQ(set_properties_from_args(filter, &result, &argc, argv), 0);

    EXPECT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);

    EXPECT_EQ(result, 0);

}

/**

 * @test       bus_neg

 * @brief      Test: set_properties_from_args

 * @details    When passed with invalid argument for the bus, 

 *             the function returns an error. 

 */

TEST_P(argsfilter_c_p, bus_neg) {

    char zero[20];

    char one[20];

    char two[20];

    char three[20];

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

    int argc = 4;

    fpga_result result;

    fpga_properties filter = NULL;

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

    strcpy(zero, "fpgainfo");

    strcpy(one, "fme");

    strcpy(two, "-B");

    strcpy(three, "zxyw");

    EXPECT_NE(set_properties_from_args(filter, &result, &argc, argv), 0);

    EXPECT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);

}

/**

 * @test       device

 * @brief      Test: set_properties_from_args

 * @details    When passed with valid argument for the device, 

 *             the function returns 0. 

 */

TEST_P(argsfilter_c_p, device) {

    char zero[20];

    char one[20];

    char two[20];

    char three[20];

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

    int argc = 4;

    fpga_result result;

    char device[10];

    sprintf(device, "0x%x", platform_.devices[0].device);

    fpga_properties filter = NULL;

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

    strcpy(zero, "fpgainfo");

    strcpy(one, "fme");

    strcpy(two, "-D");

    strcpy(three, device);

    EXPECT_EQ(set_properties_from_args(filter, &result, &argc, argv), 0);

    EXPECT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);

    EXPECT_EQ(result, 0);

}

/**

 * @test       device_neg

 * @brief      Test: set_properties_from_args

 * @details    When passed with invalid argument for the device, 

 *             the function returns an error. 

 */

TEST_P(argsfilter_c_p, device_neg) {

    char zero[20];

    char one[20];

    char two[20];

    char three[20];

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

    int argc = 4;

    fpga_result result;

    fpga_properties filter = NULL;

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

    strcpy(zero, "fpgainfo");

    strcpy(one, "fme");

    strcpy(two, "-D");

    strcpy(three, "zxyw");

    EXPECT_NE(set_properties_from_args(filter, &result, &argc, argv), 0);

    EXPECT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);

}

/**

 * @test       function

 * @brief      Test: set_properties_from_args

 * @details    When passed with valid argument for the function, 

 *             the function returns 0. 

 */

TEST_P(argsfilter_c_p, function) {

    char zero[20];

    char one[20];

    char two[20];

    char three[20];

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

    int argc = 4;

    fpga_result result;

    char function[10];

    sprintf(function, "0x%x", platform_.devices[0].function);

    fpga_properties filter = NULL;

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

    strcpy(zero, "fpgainfo");

    strcpy(one, "fme");

    strcpy(two, "-F");

    strcpy(three, function);

    EXPECT_EQ(set_properties_from_args(filter, &result, &argc, argv), 0);

    EXPECT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);

    EXPECT_EQ(result, 0);

}

/**

 * @test       function_neg

 * @brief      Test: set_properties_from_args

 * @details    When passed with invalid argument for the function, 

 *             the function returns an error. 

 */

TEST_P(argsfilter_c_p, function_neg) {

    char zero[20];

    char one[20];

    char two[20];

    char three[20];

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

    int argc = 4;

    fpga_result result;

    fpga_properties filter = NULL;

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

    strcpy(zero, "fpgainfo");

    strcpy(one, "fme");

    strcpy(two, "-F");

    strcpy(three, "zxyw");

    EXPECT_NE(set_properties_from_args(filter, &result, &argc, argv), 0);

    EXPECT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);

}

/**

 * @test       socket_id

 * @brief      Test: set_properties_from_args

 * @details    When passed with valid argument for the socket_id, 

 *             the function returns 0. 

 */

TEST_P(argsfilter_c_p, socket_id) {

    char zero[20];

    char one[20];

    char two[20];

    char three[20];

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

    int argc = 4;

    fpga_result result;

    char socket_id[10];

    sprintf(socket_id, "0x%x", platform_.devices[0].socket_id);

    fpga_properties filter = NULL;

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

    strcpy(zero, "fpgainfo");

    strcpy(one, "fme");

    strcpy(two, "-S");

    strcpy(three, socket_id);

    EXPECT_EQ(set_properties_from_args(filter, &result, &argc, argv), 0);

    EXPECT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);

    EXPECT_EQ(result, 0);

}

/**

 * @test       socket_neg

 * @brief      Test: set_properties_from_args

 * @details    When passed with invalid argument for the socket, 

 *             the function returns an error. 

 */

TEST_P(argsfilter_c_p, socket_neg) {

    char zero[20];

    char one[20];

    char two[20];

    char three[20];

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

    int argc = 4;

    fpga_result result;

    fpga_properties filter = NULL;

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

    strcpy(zero, "fpgainfo");

    strcpy(one, "fme");

    strcpy(two, "-S");

    strcpy(three, "zxyw");

    EXPECT_NE(set_properties_from_args(filter, &result, &argc, argv), 0);

    EXPECT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);

}

/**

 * @test       segment

 * @brief      Test: set_properties_from_args

 * @details    When passed with valid argument for the segment, 

 *             the function returns 0. 

 */

TEST_P(argsfilter_c_p, segment) {

    char zero[20];

    char one[20];

    char two[20];

    char three[20];

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

    int argc = 4;

    fpga_result result;

    char segment[10];

    sprintf(segment, "0x%x", platform_.devices[0].segment);

    fpga_properties filter = NULL;

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

    strcpy(zero, "fpgainfo");

    strcpy(one, "fme");

    strcpy(two, "--segment");

    strcpy(three, segment);

    EXPECT_EQ(set_properties_from_args(filter, &result, &argc, argv), 0);

    EXPECT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);

    EXPECT_EQ(result, 0);

}

/**

 * @test       segment_neg

 * @brief      Test: set_properties_from_args

 * @details    When passed with valid argument for the segment, 

 *             the function returns 0. 

 */

TEST_P(argsfilter_c_p, segment_neg) {

    char zero[20];

    char one[20];

    char two[20];

    char three[20];

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

    int argc = 4;

    fpga_result result;

    fpga_properties filter = NULL;

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

    strcpy(zero, "fpgainfo");

    strcpy(one, "fme");

    strcpy(two, "--segment");

    strcpy(three, "zxyw");

    EXPECT_NE(set_properties_from_args(filter, &result, &argc, argv), 0);

    EXPECT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);

}

/**

 * @test       argsfilter_neg

 * @brief      Test: set_properties_from_args

 * @details    When missing an argument for the bus, 

 *             the function returns an error. 

 */

TEST_P(argsfilter_c_p, argsfilter_neg) {

    char zero[20];

    char one[20];

    char two[20];

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

    int argc = 3;

    fpga_result result;

    fpga_properties filter = NULL;

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

    strcpy(zero, "fpgainfo");

    strcpy(one, "fme");

    strcpy(two, "-B");

    EXPECT_NE(set_properties_from_args(filter, &result, &argc, argv), 0);

    EXPECT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);

}

INSTANTIATE_TEST_CASE_P(argsfilter_c, argsfilter_c_p,

        ::testing::ValuesIn(test_platform::platforms()));