// Copyright(c) 2018, 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 <uuid/uuid.h>
#include <fstream>
#include "gtest/gtest.h"
#include "mock/test_system.h"
#include "types_int.h"
#include "xfpga.h"
#include "sysfs_int.h"
extern "C" {
int xfpga_plugin_initialize(void);
int xfpga_plugin_finalize(void);
}
using namespace opae::testing;
const std::string DATA =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
class sysobject_p : public ::testing::TestWithParam<std::string> {
protected:
sysobject_p()
: tokens_{{nullptr, nullptr}},
handle_(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);
fpga_guid fme_guid;
ASSERT_EQ(uuid_parse(platform_.devices[0].fme_guid, fme_guid), 0);
ASSERT_EQ(xfpga_fpgaGetProperties(nullptr, &dev_filter_), FPGA_OK);
ASSERT_EQ(fpgaPropertiesSetGUID(dev_filter_, fme_guid), FPGA_OK);
ASSERT_EQ(fpgaPropertiesSetObjectType(dev_filter_, FPGA_DEVICE), FPGA_OK);
}
virtual void TearDown() override {
EXPECT_EQ(fpgaDestroyProperties(&dev_filter_), FPGA_OK);
if (handle_) {
EXPECT_EQ(xfpga_fpgaClose(handle_), FPGA_OK);
handle_ = nullptr;
}
for (auto &t : tokens_) {
if (t) {
EXPECT_EQ(xfpga_fpgaDestroyToken(&t), FPGA_OK);
t = nullptr;
}
}
xfpga_plugin_finalize();
system_->finalize();
}
std::array<fpga_token, 2> tokens_;
fpga_handle handle_;
test_platform platform_;
test_system *system_;
fpga_properties dev_filter_;
};
TEST_P(sysobject_p, xfpga_fpgaTokenGetObject) {
uint32_t num_matches = 0;
ASSERT_EQ(xfpga_fpgaEnumerate(&dev_filter_, 1, tokens_.data(), tokens_.size(),
&num_matches),
FPGA_OK);
ASSERT_GT(num_matches, 0);
const char *name = "bitstream_id";
fpga_object object;
int flags = 0;
EXPECT_EQ(xfpga_fpgaTokenGetObject(tokens_[0], name, &object, flags),
FPGA_OK);
uint64_t bitstream_id = 0;
EXPECT_EQ(xfpga_fpgaObjectRead64(object, &bitstream_id, 0),
FPGA_OK);
EXPECT_EQ(bitstream_id, platform_.devices[0].bbs_id);
EXPECT_EQ(xfpga_fpgaTokenGetObject(tokens_[0], "invalid_name", &object, 0),
FPGA_NOT_FOUND);
EXPECT_EQ(xfpga_fpgaTokenGetObject(tokens_[0], "../../../fpga", &object, 0),
FPGA_INVALID_PARAM);
EXPECT_EQ(xfpga_fpgaDestroyObject(&object), FPGA_OK);
}
TEST_P(sysobject_p, xfpga_fpgaHandleGetObject) {
uint32_t num_matches = 0;
ASSERT_EQ(xfpga_fpgaEnumerate(&dev_filter_, 1, tokens_.data(), tokens_.size(),
&num_matches),
FPGA_OK);
ASSERT_GT(num_matches, 0);
ASSERT_EQ(xfpga_fpgaOpen(tokens_[0], &handle_, 0), FPGA_OK);
const char *name = "bitstream_id";
fpga_object object;
int flags = 0;
ASSERT_EQ(xfpga_fpgaHandleGetObject(handle_, name, &object, flags), FPGA_OK);
uint64_t bitstream_id = 0;
EXPECT_EQ(xfpga_fpgaObjectRead64(object, &bitstream_id, 0),
FPGA_OK);
EXPECT_EQ(bitstream_id, platform_.devices[0].bbs_id);
EXPECT_EQ(xfpga_fpgaHandleGetObject(handle_, "invalid_name", &object, 0),
FPGA_NOT_FOUND);
EXPECT_EQ(xfpga_fpgaHandleGetObject(handle_, "../../../fpga", &object, 0),
FPGA_INVALID_PARAM);
EXPECT_EQ(xfpga_fpgaHandleGetObject(handle_, "errors/../../../../fpga", &object, 0),
FPGA_INVALID_PARAM);
EXPECT_EQ(xfpga_fpgaDestroyObject(&object), FPGA_OK);
}
TEST_P(sysobject_p, xfpga_fpgaObjectGetObject) {
uint32_t num_matches = 0;
ASSERT_EQ(xfpga_fpgaEnumerate(&dev_filter_, 1, tokens_.data(), tokens_.size(),
&num_matches),
FPGA_OK);
ASSERT_GT(num_matches, 0);
fpga_object err_object, object, non_object;
int flags = 0;
const char *name = "errors";
EXPECT_EQ(xfpga_fpgaTokenGetObject(tokens_[0], name, &err_object, flags),
FPGA_OK);
ASSERT_EQ(xfpga_fpgaObjectGetObject(err_object, "revision", &object,
flags),
FPGA_OK);
EXPECT_EQ(xfpga_fpgaHandleGetObject(err_object, "../../../fpga", &non_object, 0),
FPGA_INVALID_PARAM);
uint64_t bbs_errors = 0;
EXPECT_EQ(xfpga_fpgaObjectRead64(object, &bbs_errors, 0),
FPGA_OK);
EXPECT_EQ(xfpga_fpgaDestroyObject(&object), FPGA_OK);
EXPECT_EQ(xfpga_fpgaDestroyObject(&err_object), FPGA_OK);
}
TEST_P(sysobject_p, xfpga_fpgaDestroyObject) {
EXPECT_EQ(xfpga_fpgaDestroyObject(NULL), FPGA_INVALID_PARAM);
}
INSTANTIATE_TEST_CASE_P(sysobject_c, sysobject_p,
::testing::ValuesIn(test_platform::platforms({ "skx-p","dcp-rc","dcp-vc" })));
class sysobject_mock_p : public sysobject_p{
protected:
sysobject_mock_p() {};
};
TEST_P(sysobject_mock_p, xfpga_fpgaObjectRead) {
uint32_t num_matches = 0;
ASSERT_EQ(xfpga_fpgaEnumerate(&dev_filter_, 1, tokens_.data(), tokens_.size(),
&num_matches),
FPGA_OK);
ASSERT_GT(num_matches, 0);
_fpga_token *tk = static_cast<_fpga_token *>(tokens_[0]);
std::string syspath(tk->sysfspath);
syspath += "/testdata";
auto fp = system_->register_file(syspath);
ASSERT_NE(fp, nullptr) << strerror(errno);
fwrite(DATA.c_str(), DATA.size(), 1, fp);
fflush(fp);
fpga_object object;
int flags = 0;
ASSERT_EQ(xfpga_fpgaTokenGetObject(tokens_[0], "testdata", &object, flags),
FPGA_OK);
std::vector<uint8_t> buffer(DATA.size());
EXPECT_EQ(xfpga_fpgaObjectRead(object, buffer.data(), 0, DATA.size() + 1, 0),
FPGA_INVALID_PARAM);
EXPECT_EQ(xfpga_fpgaObjectRead(object, buffer.data(), 0, 10, FPGA_OBJECT_SYNC),
FPGA_OK);
buffer[10] = '\0';
EXPECT_STREQ(reinterpret_cast<const char *>(buffer.data()),
DATA.substr(0, 10).c_str());
rewind(fp);
std::string c0c0str = "0xc0c0cafe\n";
uint64_t value = 0;
fwrite(c0c0str.c_str(), c0c0str.size(), 1, fp);
fflush(fp);
fclose(fp);
EXPECT_EQ(xfpga_fpgaObjectRead64(object, &value, FPGA_OBJECT_SYNC), FPGA_OK);
EXPECT_EQ(value, 0xc0c0cafe);
EXPECT_EQ(xfpga_fpgaDestroyObject(&object), FPGA_OK);
}
TEST_P(sysobject_mock_p, xfpga_fpgaObjectWrite64) {
uint32_t num_matches = 0;
ASSERT_EQ(xfpga_fpgaEnumerate(&dev_filter_, 1, tokens_.data(), tokens_.size(),
&num_matches),
FPGA_OK);
ASSERT_GT(num_matches, 0);
ASSERT_EQ(xfpga_fpgaOpen(tokens_[0], &handle_, 0), FPGA_OK);
_fpga_handle *h = static_cast<_fpga_handle *>(handle_);
_fpga_token *tok = static_cast<_fpga_token *>(h->token);
std::string syspath(tok->sysfspath);
syspath += "/testdata";
auto fp = system_->register_file(syspath);
fpga_object object;
ASSERT_EQ(xfpga_fpgaHandleGetObject(handle_, "testdata", &object, 0),
FPGA_OK);
EXPECT_EQ(xfpga_fpgaObjectWrite64(object, 0xc0c0cafe, 0), FPGA_OK);
EXPECT_EQ(xfpga_fpgaObjectWrite64(object, 0xc0c0cafe, 0),
FPGA_OK);
_fpga_object *obj = static_cast<_fpga_object *>(object);
char *path = obj->path;
std::string invalid_path = "test";
char *inv_path = new char[invalid_path.length() + 1];
strcpy(inv_path, invalid_path.c_str());
obj->path = inv_path;
EXPECT_EQ(xfpga_fpgaObjectWrite64(object, 0xc0c0cafe, 0), FPGA_EXCEPTION);
obj->path = path;
delete[] inv_path;
rewind(fp);
std::vector<char> buffer(256);
auto result = fread(buffer.data(), buffer.size(), 1, fp);
(void) result;
fclose(fp);
EXPECT_EQ(xfpga_fpgaDestroyObject(&object), FPGA_OK);
}
TEST_P(sysobject_mock_p, xfpga_fpgaGetSize) {
uint32_t num_matches = 0;
ASSERT_EQ(xfpga_fpgaEnumerate(&dev_filter_, 1, tokens_.data(), tokens_.size(),
&num_matches),
FPGA_OK);
ASSERT_GT(num_matches, 0);
_fpga_token *tk = static_cast<_fpga_token *>(tokens_[0]);
std::string syspath(tk->sysfspath);
syspath += "/testdata";
auto fp = system_->register_file(syspath);
ASSERT_NE(fp, nullptr) << strerror(errno);
fwrite(DATA.c_str(), DATA.size(), 1, fp);
fflush(fp);
fclose(fp);
fpga_object object;
int flags = 0;
ASSERT_EQ(xfpga_fpgaTokenGetObject(tokens_[0], "testdata", &object, flags),
FPGA_OK);
uint32_t value = 0;
EXPECT_EQ(xfpga_fpgaObjectGetSize(object, &value, 0), FPGA_OK);
EXPECT_EQ(value, DATA.size());
EXPECT_EQ(xfpga_fpgaDestroyObject(&object), FPGA_OK);
}
INSTANTIATE_TEST_CASE_P(sysobject_c, sysobject_mock_p,
::testing::ValuesIn(test_platform::mock_platforms({})));