// Copyright(c) 2017-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.

extern "C"{

#include "token_list_int.h"

}

#include "gtest/gtest.h"

#include "mock/test_system.h"

#include "xfpga.h"

#include "types_int.h"

#include "opae/mmio.h"

#include "intel-fpga.h"

#include "fpga-dfl.h"

#include "opae/access.h"

#include "linux/ioctl.h"

#include "cstdarg"

#include "error_int.h"

extern "C" {

int xfpga_plugin_initialize(void);

int xfpga_plugin_finalize(void);

}

using namespace opae::testing;

#ifndef BUILD_ASE

/*

 * On hardware, the mmio map is a hash table.

 */

static bool mmio_map_is_empty(struct wsid_tracker *root) {

  if (!root || (root->n_hash_buckets == 0))

    return true;

  for (uint32_t i = 0; i < root->n_hash_buckets; i += 1) {

    if (root->table[i])

      return false;

  }

  return true;

}

#else

/*

 * In ASE, the mmio map is a list.

 */

static bool mmio_map_is_empty(struct wsid_map *root) {

  return !root;

}

#endif

#undef FPGA_MSG

#define FPGA_MSG(fmt, ...) \

	printf("MOCK " fmt "\n", ## __VA_ARGS__)

int mmio_ioctl(mock_object * m, int request, va_list argp){

    int retval = -1;

    errno = EINVAL;

    UNUSED_PARAM(m);

    UNUSED_PARAM(request);

    struct fpga_port_region_info *rinfo = va_arg(argp, struct fpga_port_region_info *);

    if (!rinfo) {

      FPGA_MSG("rinfo is NULL");

      goto out_EINVAL;

    }

    if (rinfo->argsz != sizeof(*rinfo)) {

      FPGA_MSG("wrong structure size");

      goto out_EINVAL;

    }

    if (rinfo->index > 1 ) {

      FPGA_MSG("unsupported MMIO index");

      goto out_EINVAL;

    }

    if (rinfo->padding != 0) {

      FPGA_MSG("unsupported padding");

      goto out_EINVAL;

    }

    rinfo->flags = FPGA_REGION_READ | FPGA_REGION_WRITE | FPGA_REGION_MMAP;

    rinfo->size = 0x40000;

    rinfo->offset = 0;

    retval = 0;

    errno = 0;

out:

    return retval;

out_EINVAL:

    retval = -1;

    errno = EINVAL;

    goto out;

}

class openclose_c_p

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

 protected:

  openclose_c_p()

  : handle_(nullptr),

    tokens_{{nullptr, nullptr}} {}

  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_);

    ASSERT_EQ(xfpga_plugin_initialize(), FPGA_OK);

    ASSERT_EQ(xfpga_fpgaGetProperties(nullptr, &filter_), FPGA_OK);

    ASSERT_EQ(fpgaPropertiesSetObjectType(filter_, FPGA_ACCELERATOR), FPGA_OK);

    ASSERT_EQ(xfpga_fpgaEnumerate(&filter_, 1, tokens_.data(), tokens_.size(),

                            &num_matches_),

              FPGA_OK);

  }

  virtual void TearDown() override {

    EXPECT_EQ(fpgaDestroyProperties(&filter_), FPGA_OK);

    for (auto &t : tokens_){

      if (t) {

        EXPECT_EQ(FPGA_OK, xfpga_fpgaDestroyToken(&t);;

        t = nullptr;

      }

    }

    xfpga_plugin_finalize();

    system_->finalize();

  }

  fpga_handle handle_;

  std::array<fpga_token, 2> tokens_;

  fpga_properties filter_;

  uint32_t num_matches_;

  test_platform platform_;

  test_system *system_;

};

/**

 * @test       open_01

 *

 * @brief      When the fpga_handle * parameter to xfpga_fpgaOpen is NULL, the

 *             function returns FPGA_INVALID_PARAM.

 */

TEST_P(openclose_c_p, open_01) {

  fpga_result res;

  res = xfpga_fpgaOpen(NULL, NULL, 0);

  ASSERT_EQ(FPGA_INVALID_PARAM, res);

}

/**

 * @test       open_02

 *

 * @brief      When the fpga_token parameter to xfpga_fpgaOpen is NULL, the

 *             function returns FPGA_INVALID_PARAM.

 */

TEST_P(openclose_c_p, open_02) {

  fpga_handle handle_;

  ASSERT_EQ(FPGA_INVALID_PARAM, xfpga_fpgaOpen(NULL, &handle_, 0));

}

/**

 * @test       open_03

 *

 * @brief      When the flags parameter to xfpga_fpgaOpen is invalid, the

 *             function returns FPGA_INVALID_PARAM.

 *

 */

TEST_P(openclose_c_p, open_03) {

  ASSERT_EQ(FPGA_INVALID_PARAM, xfpga_fpgaOpen(tokens_[0], NULL, 42));

  ASSERT_EQ(FPGA_INVALID_PARAM, xfpga_fpgaOpen(tokens_[0], &handle_, 42));

}

/**

 * @test       open_04

 *

 * @brief      When the flags parameter to xfpga_fpgaOpen is invalid, the

 *             function returns FPGA_INVALID_PARAM.

 *

 */

TEST_P(openclose_c_p, open_04) {

  auto _token = (struct _fpga_token*)tokens_[0];

  auto res = xfpga_fpgaOpen(tokens_[0], &handle_, 42);

  ASSERT_EQ(FPGA_INVALID_PARAM, res);

  // Invalid token magic

  _token->magic = 0x123;

  res = xfpga_fpgaOpen(tokens_[0], &handle_, FPGA_OPEN_SHARED);

  ASSERT_EQ(FPGA_INVALID_PARAM, res);

  // Reset token magic

  _token->magic = FPGA_TOKEN_MAGIC;

}

/**

 * @test       open_05

 *

 * @brief      When the flags parameter to xfpga_fpgaOpen is invalid, the

 *             function returns FPGA_INVALID_PARAM and FPGA_NO_DRIVER.

 *

 */

TEST_P(openclose_c_p, open_05) {

  fpga_result res;

  struct _fpga_token* _token = (struct _fpga_token*)tokens_[0];

  // Invalid flag

  res = xfpga_fpgaOpen(tokens_[0], &handle_, 42);

  ASSERT_EQ(FPGA_INVALID_PARAM, res);

  handle_ = nullptr; 

  // Valid flag

  res = xfpga_fpgaOpen(tokens_[0], &handle_, FPGA_OPEN_SHARED);

  ASSERT_EQ(FPGA_OK, res);

  ASSERT_EQ(FPGA_OK, xfpga_fpgaClose(handle_));

  // Invalid token path

  strcpy(_token->devpath,"/dev/intel-fpga-fme.01");

  res = xfpga_fpgaOpen(tokens_[0], &handle_, FPGA_OPEN_SHARED);

  ASSERT_EQ(FPGA_NO_DRIVER, res);

}

/**

 * @test       open_06

 *

 * @brief      When the flags parameter to xfpga_fpgaOpen is valid, 

 *             but malloc fails. the function returns FPGA_NO_MEMORY.

 *

 */

TEST_P(openclose_c_p, open_06) {

  system_->invalidate_malloc();

  auto res = xfpga_fpgaOpen(tokens_[0], &handle_, 0);

  ASSERT_EQ(FPGA_NO_MEMORY, res);

}

/**

 * @test       close_01 

 *

 * @brief      When the flags parameter to xfpga_fpgaOpen is valid, 

 *             but handle fd is invalid. the function returns 

 *             FPGA_INVALID_PARAM.

 *

 */

TEST_P(openclose_c_p, close_01) {

  int fddev = -1;

  auto res = xfpga_fpgaOpen(tokens_[0], &handle_, 0);

  ASSERT_EQ(FPGA_OK, res);

  struct _fpga_handle* _handle = (struct _fpga_handle*)handle_;

  // Invalid handle fd

  fddev = _handle->fddev;

  _handle->fddev = -1;

  res = xfpga_fpgaClose(handle_);

  EXPECT_EQ(res, FPGA_INVALID_PARAM);

  // Valid handle fd

  _handle->fddev = fddev;

   res = xfpga_fpgaClose(handle_);

  EXPECT_EQ(res, FPGA_OK);

}

/**

 * @test       invalid_close

 *

 * @brief      When the fpga_handle parameter to fpgaClose is NULL, the

 *             function returns FPGA_INVALID_PARAM.

 */

TEST_P(openclose_c_p, invalid_close) {

  EXPECT_EQ(FPGA_INVALID_PARAM, xfpga_fpgaClose(NULL));

}

/**

 * @test       close_03

 *

 * @brief      When the flags parameter to xfpga_fpgaOpen is valid, it 

 *             returns FPGA_OK.  

 *             the function returns FPGA_INVALID_PARAM.

 *

 */

TEST_P(openclose_c_p, close_03) {

  uint64_t * mmio_ptr = nullptr;

  auto res = xfpga_fpgaOpen(tokens_[0], &handle_, 0);

  ASSERT_EQ(FPGA_OK, res);

  // Register valid ioctl

  system_->register_ioctl_handler(FPGA_PORT_GET_REGION_INFO, mmio_ioctl);

  system_->register_ioctl_handler(DFL_FPGA_PORT_GET_REGION_INFO, mmio_ioctl);

  EXPECT_TRUE(mmio_map_is_empty(((struct _fpga_handle*)handle_)->mmio_root));

  ASSERT_EQ(FPGA_OK, xfpga_fpgaMapMMIO(handle_, 0, &mmio_ptr));

  EXPECT_NE(mmio_ptr,nullptr);

  res = xfpga_fpgaClose(handle_);

  EXPECT_EQ(res, FPGA_OK);

}

INSTANTIATE_TEST_CASE_P(openclose_c, openclose_c_p, 

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

class openclose_c_skx_dcp_p

    : public openclose_c_p {};

/**

 * @test       open_share

 *

 * @brief      When the parameters are valid and the drivers are loaded,

 *             and the flag FPGA_OPEN_SHARED is given, fpgaOpen on an

 *             already opened token returns FPGA_OK.

 */

TEST_P(openclose_c_skx_dcp_p, open_share) {

  fpga_handle h1 = nullptr;

  fpga_handle h2 = nullptr;

  EXPECT_EQ(FPGA_OK, xfpga_fpgaOpen(tokens_[0], &h1, FPGA_OPEN_SHARED));

  EXPECT_EQ(FPGA_OK, xfpga_fpgaOpen(tokens_[0], &h2, FPGA_OPEN_SHARED));

  EXPECT_EQ(FPGA_OK, xfpga_fpgaClose(h1));

  EXPECT_EQ(FPGA_OK, xfpga_fpgaClose(h2));

}

INSTANTIATE_TEST_CASE_P(openclose_c_skx_dcp, openclose_c_skx_dcp_p,

                        ::testing::ValuesIn(test_platform::platforms({}, fpga_driver::linux_intel)));

class openclose_c_dfl_p

    : public openclose_c_p {};

/**

 * @test       open_share

 *

 * @brief      When the parameters are valid and the drivers are loaded,

 *             and the flag FPGA_OPEN_SHARED is given, fpgaOpen on an

 *             already opened token returns FPGA_BUSY.

 */

TEST_P(openclose_c_dfl_p, open_share) {

  fpga_handle h1 = nullptr;

  fpga_handle h2 = nullptr;

  EXPECT_EQ(FPGA_OK, xfpga_fpgaOpen(tokens_[0], &h1, FPGA_OPEN_SHARED));

  EXPECT_EQ(FPGA_BUSY, xfpga_fpgaOpen(tokens_[0], &h2, FPGA_OPEN_SHARED));

  EXPECT_EQ(FPGA_OK, xfpga_fpgaClose(h1));

}

INSTANTIATE_TEST_CASE_P(openclose_c_dfl, openclose_c_dfl_p,

                        ::testing::ValuesIn(test_platform::hw_platforms({}, fpga_driver::linux_dfl0)));

/**

 * @test       invalid_open_close

 *

 * @brief      When the flags parameter to xfpga_fpgaOpen is valid, 

 *             but driver is not loaded. the function returns FPGA_NO_DRIVER.

 *

 */

class openclose_c_mock_p

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

 protected:

  openclose_c_mock_p() {}

};

TEST_P(openclose_c_mock_p, invalid_open_close) {

  struct _fpga_token _tok;

  fpga_token tok = &_tok;

  fpga_handle h;

  const std::string sysfs_port = "/sys/class/fpga/intel-fpga-dev.0/intel-fpga-port.0";

  const std::string dev_port = "/dev/intel-fpga-port.0";

  // token setup

  strncpy(_tok.sysfspath, sysfs_port.c_str(), sysfs_port.size() + 1);

  strncpy(_tok.devpath, dev_port.c_str(), dev_port.size() + 1);

  _tok.magic = FPGA_TOKEN_MAGIC;

  _tok.errors = nullptr;

  std::string errpath = sysfs_port + "/errors";

  build_error_list(errpath.c_str(), &_tok.errors);

#ifdef BUILD_ASE

  ASSERT_EQ(FPGA_OK, xfpga_fpgaOpen(tok, &h, 0));

  ASSERT_EQ(FPGA_OK, xfpga_fpgaClose(h));

  EXPECT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);

  EXPECT_EQ(FPGA_OK, xfpga_fpgaDestroyToken(&tok));

#else

  EXPECT_EQ(FPGA_NO_DRIVER, xfpga_fpgaOpen(tok, &h, 0));

#endif

}

INSTANTIATE_TEST_CASE_P(openclose_c, openclose_c_mock_p, 

                        ::testing::ValuesIn(test_platform::mock_platforms({})));