// 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 "libbitstream/bitstream.h"
extern "C" {
fpga_result opae_bitstream_read_file(const char *file,
uint8_t **buf,
size_t *len);
void opae_resolve_legacy_bitstream(opae_bitstream_info *info);
void *opae_bitstream_parse_metadata(const char *metadata,
fpga_guid pr_interface_id,
int *version);
fpga_result opae_resolve_bitstream(opae_bitstream_info *info);
extern fpga_guid valid_GBS_guid;
}
#include <config.h>
#include <opae/fpga.h>
#include <fstream>
#include <vector>
#include "gtest/gtest.h"
#include "mock/test_system.h"
const fpga_guid guid = {
0x02, 0x7f, 0x3a, 0x1a,
0xcb, 0x3b,
0x0c, 0x87,
0x53, 0x4b,
0x56, 0x7d, 0x4a, 0xf6, 0x93, 0xe9
};
const fpga_guid guid_reversed = {
0xe9, 0x93, 0xf6, 0x4a,
0x7d, 0x56,
0x4b, 0x53,
0x87, 0x0c,
0x3b, 0xcb, 0x1a, 0x3a, 0x7f, 0x02
};
using namespace opae::testing;
class bitstream_c_p : public ::testing::TestWithParam<std::string> {
protected:
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_);
strcpy(tmpnull_gbs_, "tmpnull-XXXXXX.gbs");
close(mkstemps(tmpnull_gbs_, 4));
null_gbs_ = system_->assemble_gbs_header(platform_.devices[0]);
std::ofstream gbs;
gbs.open(tmpnull_gbs_, std::ios::out|std::ios::binary);
gbs.write((const char *) null_gbs_.data(), null_gbs_.size());
gbs.close();
}
virtual void TearDown() override {
system_->finalize();
if (!::testing::Test::HasFatalFailure() &&
!::testing::Test::HasNonfatalFailure()) {
unlink(tmpnull_gbs_);
}
}
char tmpnull_gbs_[20];
std::vector<uint8_t> null_gbs_;
test_platform platform_;
test_system *system_;
};
/**
* @test read_err0
* @brief Test: opae_bitstream_read_file
* @details If the given file doesn't exist,<br>
* the fn returns FPGA_EXCEPTION.<br>
*/
TEST_P(bitstream_c_p, read_err0) {
uint8_t *buf = nullptr;
size_t len = 0;
EXPECT_EQ(opae_bitstream_read_file("doesntexist", &buf, &len),
FPGA_EXCEPTION);
}
/**
* @test is_legacy
* @brief Test: opae_is_legacy_bitstream
* @details If the given info pointer is that for a<br>
* legacy format bitstream,<br>
* the fn returns true.<br>
*/
TEST_P(bitstream_c_p, is_legacy) {
opae_legacy_bitstream_header hdr;
hdr.legacy_magic = OPAE_LEGACY_BITSTREAM_MAGIC;
opae_bitstream_info info;
info.data = (uint8_t *)&hdr;
info.data_len = sizeof(hdr);
EXPECT_TRUE(opae_is_legacy_bitstream(&info));
}
/**
* @test resolve_legacy
* @brief Test: opae_resolve_legacy_bitstream
* @details Given an opae_bitstream_info with data and<br>
* data_len fields populated,<br>
* opae_resolve_legacy_bitstream fills the<br>
* pr_interface_id, rbf_data, and rbf_len<br>
* fields appropriately.<br>
*/
TEST_P(bitstream_c_p, resolve_legacy) {
char buf[sizeof(opae_legacy_bitstream_header) + sizeof(uint32_t)];
opae_legacy_bitstream_header *hdr =
(opae_legacy_bitstream_header *)buf;
hdr->legacy_magic = OPAE_LEGACY_BITSTREAM_MAGIC;
memcpy(hdr->legacy_pr_ifc_id, guid, sizeof(guid));
opae_bitstream_info info;
info.data = (uint8_t *)hdr;
info.data_len = sizeof(buf);
info.metadata_version = 0;
info.parsed_metadata = nullptr;
opae_resolve_legacy_bitstream(&info);
EXPECT_EQ(info.rbf_data, (uint8_t *)&buf[sizeof(opae_legacy_bitstream_header)]);
EXPECT_EQ(info.rbf_len, sizeof(uint32_t));
EXPECT_EQ(memcmp(info.pr_interface_id, guid_reversed, sizeof(guid_reversed)), 0);
EXPECT_EQ(info.metadata_version, 0);
EXPECT_EQ(info.parsed_metadata, nullptr);
}
/**
* @test parse_err0
* @brief Test: opae_bitstream_parse_metadata
* @details If the given metadata string is not valid JSON,<br>
* the fn returns NULL.<br>
*/
TEST_P(bitstream_c_p, parse_err0) {
const char *mdata =
R"mdata({
)mdata";
fpga_guid guid;
int ver = 0;
EXPECT_EQ(opae_bitstream_parse_metadata(mdata, guid, &ver), nullptr);
}
/**
* @test parse_err1
* @brief Test: opae_bitstream_parse_metadata
* @details If the given metadata string contains no version key,<br>
* the fn returns NULL.<br>
*/
TEST_P(bitstream_c_p, parse_err1) {
const char *mdata =
R"mdata({
})mdata";
fpga_guid guid;
int ver = 0;
EXPECT_EQ(opae_bitstream_parse_metadata(mdata, guid, &ver), nullptr);
}
/**
* @test parse_err2
* @brief Test: opae_bitstream_parse_metadata
* @details If the given metadata string contains a version key,<br>
* the type of which is not integer,<br>
* the fn returns NULL.<br>
*/
TEST_P(bitstream_c_p, parse_err2) {
const char *mdata =
R"mdata({
"version": "ver"
})mdata";
fpga_guid guid;
int ver = 0;
EXPECT_EQ(opae_bitstream_parse_metadata(mdata, guid, &ver), nullptr);
}
/**
* @test parse_err3
* @brief Test: opae_bitstream_parse_metadata
* @details If the given metadata string contains a version key<br>
* which matches no valid metadata version,<br>
* the fn returns NULL.<br>
*/
TEST_P(bitstream_c_p, parse_err3) {
const char *mdata =
R"mdata({
"version": 99
})mdata";
fpga_guid guid;
int ver = 0;
EXPECT_EQ(opae_bitstream_parse_metadata(mdata, guid, &ver), nullptr);
}
/**
* @test resolve_err0
* @brief Test: opae_resolve_bitstream
* @details Given an opae_bitstream_info that has a guid<br>
* that does not match the valid GBS guid,<br>
* the fn returns FPGA_INVALID_PARAM.<br>
*/
TEST_P(bitstream_c_p, resolve_err0) {
opae_bitstream_header hdr;
memcpy(hdr.valid_gbs_guid, valid_GBS_guid, sizeof(fpga_guid));
hdr.valid_gbs_guid[0] = ~hdr.valid_gbs_guid[0];
hdr.metadata_length = 1;
opae_bitstream_info info;
info.data = (uint8_t *)&hdr;
info.data_len = sizeof(hdr);
info.filename = (char*)"dummy_file.txt";
EXPECT_EQ(opae_resolve_bitstream(&info), FPGA_INVALID_PARAM);
}
/**
* @test resolve_err1
* @brief Test: opae_resolve_bitstream
* @details Given an opae_bitstream_info that has a metadata_length<br>
* field that causes the header size to exceed the file size,<br>
* the fn returns FPGA_INVALID_PARAM.<br>
*/
TEST_P(bitstream_c_p, resolve_err1) {
opae_bitstream_header hdr;
memcpy(hdr.valid_gbs_guid, valid_GBS_guid, sizeof(fpga_guid));
hdr.metadata_length = 2;
opae_bitstream_info info;
info.filename = tmpnull_gbs_;
info.data = (uint8_t *)&hdr;
info.data_len = sizeof(hdr);
EXPECT_EQ(opae_resolve_bitstream(&info), FPGA_INVALID_PARAM);
}
/**
* @test load_err0
* @brief Test: opae_load_bitstream
* @details If either of the parameters is NULL,<br>
* the fn returns FPGA_INVALID_PARAM.<br>
*/
TEST_P(bitstream_c_p, load_err0) {
EXPECT_EQ(opae_load_bitstream(tmpnull_gbs_, nullptr), FPGA_INVALID_PARAM);
}
/**
* @test load_err1
* @brief Test: opae_load_bitstream
* @details If the given file name doesn't exist,<br>
* the fn returns FPGA_INVALID_PARAM.<br>
*/
TEST_P(bitstream_c_p, load_err1) {
opae_bitstream_info info;
EXPECT_EQ(opae_load_bitstream("doesntexist", &info), FPGA_INVALID_PARAM);
}
/**
* @test load_ok0
* @brief Test: opae_load_bitstream
* @details If the given opae_bitstream_info represents a<br>
* legacy formatted bitstream,<br>
* the fn resolve it and returns FPGA_OK.<br>
*/
TEST_P(bitstream_c_p, load_ok0) {
opae_legacy_bitstream_header hdr;
hdr.legacy_magic = OPAE_LEGACY_BITSTREAM_MAGIC;
memcpy(hdr.legacy_pr_ifc_id, guid, sizeof(fpga_guid));
std::ofstream gbs;
gbs.open(tmpnull_gbs_, std::ios::out|std::ios::binary);
gbs.write((const char *)&hdr, sizeof(hdr));
gbs.close();
opae_bitstream_info info;
EXPECT_EQ(opae_load_bitstream(tmpnull_gbs_, &info), FPGA_OK);
EXPECT_STREQ(tmpnull_gbs_, info.filename);
ASSERT_NE(info.data, nullptr);
EXPECT_EQ(info.data_len, sizeof(hdr));
EXPECT_EQ(info.rbf_data, info.data + sizeof(hdr));
EXPECT_EQ(info.rbf_len, 0);
EXPECT_EQ(memcmp(info.pr_interface_id, guid_reversed, sizeof(fpga_guid)), 0);
EXPECT_EQ(info.metadata_version, 0);
EXPECT_EQ(info.parsed_metadata, nullptr);
EXPECT_EQ(opae_unload_bitstream(&info), FPGA_OK);
}
/**
* @test unload_err0
* @brief Test: opae_unload_bitstream
* @details When passed NULL,<br>
* the fn returns FPGA_INVALID_PARAM.<br>
*/
TEST_P(bitstream_c_p, unload_err0) {
EXPECT_EQ(opae_unload_bitstream(nullptr), FPGA_INVALID_PARAM);
}
/**
* @test unload_err1
* @brief Test: opae_unload_bitstream
* @details When passed an opae_bitstream_info that<br>
* has an unsupported metadata version,
* the fn returns FPGA_EXCEPTION.<br>
*/
TEST_P(bitstream_c_p, unload_err1) {
opae_bitstream_info info;
info.data = nullptr;
info.parsed_metadata = malloc(4);
uint8_t *save = (uint8_t *)info.parsed_metadata;
info.metadata_version = 99;
EXPECT_EQ(opae_unload_bitstream(&info), FPGA_EXCEPTION);
free(save);
}
INSTANTIATE_TEST_CASE_P(bitstream_c, bitstream_c_p,
::testing::ValuesIn(test_platform::platforms({})));
class mock_bitstream_c_p : public bitstream_c_p {};
/**
* @test read_err1
* @brief Test: opae_bitstream_read_file
* @details If malloc fails,<br>
* the fn returns FPGA_NO_MEMORY.<br>
*/
TEST_P(mock_bitstream_c_p, read_err1) {
uint8_t *buf = nullptr;
size_t len = 0;
system_->invalidate_malloc(0, "opae_bitstream_read_file");
EXPECT_EQ(opae_bitstream_read_file(tmpnull_gbs_, &buf, &len), FPGA_NO_MEMORY);
}
/**
* @test resolve_err2
* @brief Test: opae_resolve_bitstream
* @details When malloc fails<br>
* the fn returns FPGA_NO_MEMORY.<br>
*/
TEST_P(mock_bitstream_c_p, resolve_err2) {
opae_bitstream_header hdr;
memcpy(hdr.valid_gbs_guid, valid_GBS_guid, sizeof(fpga_guid));
hdr.metadata_length = 1;
opae_bitstream_info info;
info.filename = tmpnull_gbs_;
info.data = (uint8_t *)&hdr;
info.data_len = sizeof(hdr);
system_->invalidate_malloc(0, "opae_resolve_bitstream");
EXPECT_EQ(opae_resolve_bitstream(&info), FPGA_NO_MEMORY);
}
INSTANTIATE_TEST_CASE_P(bitstream_c, mock_bitstream_c_p,
::testing::ValuesIn(test_platform::mock_platforms({})));