// 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 <opae/fpga.h>

extern "C" {

#include <json-c/json.h>

#include <uuid/uuid.h>

struct UserClkCommandLine

{

	int      segment;

	int      bus;

	int      device;

	int      function;

	int      socket;

	int      freq_high;

	int      freq_low;

};

extern struct UserClkCommandLine userclkCmdLine;

void UserClkAppShowHelp(void);

void print_err(const char *s, fpga_result res);

int ParseCmds(struct UserClkCommandLine *userclkCmdLine, int argc, char *argv[]);

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

}

#include <config.h>

#include <iostream>

#include <vector>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <errno.h>

#include <unistd.h>

#include "gtest/gtest.h"

#include "mock/test_system.h"

using namespace opae::testing;

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

 protected:

  userclk_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(NULL), FPGA_OK);

    optind = 0;

    cmd_line_ = userclkCmdLine;

  }

  virtual void TearDown() override {

    userclkCmdLine = cmd_line_;

    fpgaFinalize();

    system_->finalize();

  }

  struct UserClkCommandLine cmd_line_;

  test_platform platform_;

  test_system *system_;

};

/**

 * @test       help

 * @brief      Test: UserClkAppShowHelp

 * @details    UserClkAppShowHelp displays the application help message.

 */

TEST_P(userclk_c_p, help) {

  UserClkAppShowHelp();

}

/**

 * @test       print_err

 * @brief      Test: print_err

 * @details    print_err prints the given string and

 *             the decoded representation of the fpga_result

 *             to stderr.

 */

TEST_P(userclk_c_p, print_err) {

  print_err("msg", FPGA_OK);

}

/**

 * @test       parse_cmd0

 * @brief      Test: ParseCmds

 * @details    When passed an invalid command option,

 *             ParseCmds prints a message and

 *             returns a negative value.

 */

TEST_P(userclk_c_p, parse_cmd0) {

  struct UserClkCommandLine cmd;

  char zero[20];

  char one[20];

  strcpy(zero, "userclk");

  strcpy(one, "-Y");

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

  EXPECT_LT(ParseCmds(&cmd, 2, argv), 0);

}

/**

 * @test       parse_cmd1

 * @brief      Test: ParseCmds

 * @details    When called with "-h",

 *             ParseCmds prints the app help and

 *             returns a negative value.

 */

TEST_P(userclk_c_p, parse_cmd1) {

  struct UserClkCommandLine cmd;

  char zero[20];

  char one[20];

  strcpy(zero, "userclk");

  strcpy(one, "-h");

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

  EXPECT_LT(ParseCmds(&cmd, 2, argv), 0);

}

/**

 * @test       parse_cmd2

 * @brief      Test: ParseCmds

 * @details    When given a command option that requires a param,

 *             omitting the required param causes ParseCmds to

 *             return a negative value.

 */

TEST_P(userclk_c_p, parse_cmd2) {

  struct UserClkCommandLine cmd;

  char zero[20];

  char one[20];

  strcpy(zero, "userclk");

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

  strcpy(one, "--segment");

  EXPECT_LT(ParseCmds(&cmd, 2, argv), 0);

  optind = 0;

  strcpy(one, "-B");

  EXPECT_LT(ParseCmds(&cmd, 2, argv), 0);

  optind = 0;

  strcpy(one, "-D");

  EXPECT_LT(ParseCmds(&cmd, 2, argv), 0);

  optind = 0;

  strcpy(one, "-F");

  EXPECT_LT(ParseCmds(&cmd, 2, argv), 0);

  optind = 0;

  strcpy(one, "-S");

  EXPECT_LT(ParseCmds(&cmd, 2, argv), 0);

  optind = 0;

  strcpy(one, "-P");

  EXPECT_LT(ParseCmds(&cmd, 2, argv), 0);

  optind = 0;

  strcpy(one, "-H");

  EXPECT_LT(ParseCmds(&cmd, 2, argv), 0);

  optind = 0;

  strcpy(one, "-L");

  EXPECT_LT(ParseCmds(&cmd, 2, argv), 0);

}

/**

 * @test       parse_cmd3

 * @brief      Test: ParseCmds

 * @details    When given valid command options,

 *             ParseCmds populates the given UserClkCommandLine,

 *             returning zero.

 */

TEST_P(userclk_c_p, parse_cmd3) {

  struct UserClkCommandLine cmd = cmd_line_;

  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 twelve[20];

  char thirteen[20];

  char fourteen[20];

  strcpy(zero, "userclk");

  strcpy(one, "--segment");

  strcpy(two, "0x1234");

  strcpy(three, "-B");

  strcpy(four, "3");

  strcpy(five, "-D");

  strcpy(six, "4");

  strcpy(seven, "-F");

  strcpy(eight, "5");

  strcpy(nine, "-S");

  strcpy(ten, "6");

  strcpy(eleven, "-H");

  strcpy(twelve, "8");

  strcpy(thirteen, "-L");

  strcpy(fourteen, "9");

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

                   five, six, seven, eight, nine,

                   ten, eleven, twelve, thirteen, fourteen };

  EXPECT_EQ(ParseCmds(&cmd, 15, argv), 0);

  EXPECT_EQ(cmd.segment, 0x1234);

  EXPECT_EQ(cmd.bus, 3);

  EXPECT_EQ(cmd.device, 4);

  EXPECT_EQ(cmd.function, 5);

  EXPECT_EQ(cmd.socket, 6);

  EXPECT_EQ(cmd.freq_high, 8);

  EXPECT_EQ(cmd.freq_low, 9);

}

/**

 * @test       invalid_cmd_characters_02

 * @brief      Test: ParseCmds, userclk_main 

 * @details    When given invalid command options,

 *             ParseCmds populates the given UserClkCommandLine,

 *             returning FPGA_INVALID_PARAM.

 */

TEST_P(userclk_c_p, invalid_cmd_characters_01) {

  struct UserClkCommandLine cmd = cmd_line_;

  char zero[32];

  char one[32];

  char two[32];

  char three[32];

  char four[32];

  char five[48];

  char six[32];

  char seven[32];

  char eight[32];

  char nine[32];

  char ten[32];

  char eleven[32];

  char twelve[32];

  char thirteen[32];

  char fourteen[32];

  strcpy(zero, "userclk_+*(^> ");

  strcpy(one, "--segm ent");

  strcpy(two, "0x1234");

  strcpy(three, "-Bus");

  strcpy(four, "3");

  strcpy(five, "-Devi +_( \v           -0923198 (*)& ces");

  strcpy(six, "4");

  strcpy(seven, "-Fun\t\nction");

  strcpy(eight, "5");

  strcpy(nine, "-Sockett\e \'\?//tttttt \b");

  strcpy(ten, "6");

  strcpy(eleven, "-   High");

  strcpy(twelve, "-100");

  strcpy(thirteen, " ---Low");

  strcpy(fourteen, "-200");

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

                   five, six, seven, eight, nine,

                   ten, eleven, twelve, thirteen, fourteen };

  EXPECT_NE(ParseCmds(&cmd, 15, argv), 0);

  EXPECT_NE(userclk_main(15, argv), 0);

}

/**

 * @test       invalid_cmd_characters_02

 * @brief      Test: ParseCmds, userclk_main 

 * @details    When given invalid command options,

 *             ParseCmds populates the given UserClkCommandLine,

 *             returning zero. Userclk_main returns FPGA_INVALID_PARAM.

 */

TEST_P(userclk_c_p, invalid_cmd_characters_02) {

  struct UserClkCommandLine cmd;

  char zero[32];

  char one[32];

  char two[48];

  char three[32];

  char four[32];

  char five[32];

  char six[32];

  char seven[32];

  char eight[48];

  char nine[32];

  char ten[32];

  char eleven[32];

  char twelve[32];

  char thirteen[32];

  char fourteen[32];

  strcpy(zero, "");

  strcpy(one, "--segment");

  strcpy(two, "0x0123897349  *(^%$%^$%@^?>

  strcpy(three, " --B");

  strcpy(four, "334987238689 \x01\x05\x0a\x15");

  strcpy(five, "-D");

  strcpy(six, "41278991 02a8974913");

  strcpy(seven, "-F");

  strcpy(eight, "529378190 \t 3haskfhahhi\\ | // o=1-21");

  strcpy(nine, "-S");

  strcpy(ten, "        6`1238 \n -349287419=-0;");

  strcpy(eleven, "-H");

  strcpy(twelve, "400000000000000000000000000");

  strcpy(thirteen, "-L");

  strcpy(fourteen, "9.999");

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

                   eleven, twelve, thirteen, fourteen,

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

  EXPECT_EQ(ParseCmds(&cmd, 15, argv), 0);

  EXPECT_NE(userclk_main(15, argv), 0);

}

/**

 * @test       main0

 * @brief      Test: userclk_main

 * @details    When given no command options,

 *             userclk_main displays the app help message,

 *             and the fn returns non-zero.

 */

TEST_P(userclk_c_p, main0) {

  char zero[20];

  strcpy(zero, "userclk");

  char *argv[] = { zero };

  EXPECT_NE(userclk_main(1, argv), 0);

}

/**

 * @test       main1

 * @brief      Test: userclk_main

 * @details    When given "-h",

 *             userclk_main displays the app help message,

 *             and the fn returns non-zero.

 */

TEST_P(userclk_c_p, main1) {

  char zero[20];

  char one[20];

  strcpy(zero, "userclk");

  strcpy(one, "-h");

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

  EXPECT_NE(userclk_main(2, argv), 0);

}

/**

 * @test       main2

 * @brief      Test: userclk_main

 * @details    When given valid command parameters,

 *             but no device is identified by those parameters,

 *             userclk_main displays an error message,

 *             and the fn returns non-zero.

 */

TEST_P(userclk_c_p, main2) {

  char zero[20];

  char one[20];

  char two[20];

  strcpy(zero, "userclk");

  strcpy(one, "-B");

  strcpy(two, "99");

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

  EXPECT_NE(userclk_main(3, argv), 0);

}

INSTANTIATE_TEST_CASE_P(userclk_c, userclk_c_p,

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

class userclk_c_hw_p : public userclk_c_p{

  protected:

    userclk_c_hw_p() {};

};

/**

 * @test       main3

 * @brief      Test: userclk_main

 * @details    When given valid command parameters that identify an accelerator,

 *             if --freq-low is not given,

 *             then low is calculated from high,

 *             and the fn returns zero.

 */

TEST_P(userclk_c_hw_p, main3) {

  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 twelve[20];

  strcpy(zero, "userclk");

  strcpy(one, "--segment");

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

  strcpy(three, "-B");

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

  strcpy(five, "-D");

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

  strcpy(seven, "-F");

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

  strcpy(nine, "-S");

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

  strcpy(eleven, "-H");

  strcpy(twelve, "400");

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

                   five, six, seven, eight, nine,

                   ten, eleven, twelve };

  EXPECT_EQ(userclk_main(13, argv), FPGA_OK);

}

/**

 * @test       main4

 * @brief      Test: userclk_main

 * @details    When given valid command parameters that identify an accelerator,

 *             if --freq-high is not given,

 *             then high is calculated from low,

 *             and the fn returns zero.

 */

TEST_P(userclk_c_hw_p, main4) {

  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 twelve[20];

  strcpy(zero, "userclk");

  strcpy(one, "--segment");

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

  strcpy(three, "-B");

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

  strcpy(five, "-D");

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

  strcpy(seven, "-F");

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

  strcpy(nine, "-S");

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

  strcpy(eleven, "-L");

  strcpy(twelve, "200");

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

                   five, six, seven, eight, nine,

                   ten, eleven, twelve };

  EXPECT_EQ(userclk_main(13, argv), FPGA_OK);

}

/**

 * @test       main5

 * @brief      Test: userclk_main

 * @details    When given valid command parameters that identify an accelerator,

 *             if both --freq-high (-H) and --freq-low (-L) are given,

 *             then high must equal 2 * low,

 *             or else the fn returns FPGA_INVALID_PARAM.

 */

TEST_P(userclk_c_hw_p, main5) {

  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 twelve[20];

  char thirteen[20];

  char fourteen[20];

  strcpy(zero, "userclk");

  strcpy(one, "--segment");

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

  strcpy(three, "-B");

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

  strcpy(five, "-D");

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

  strcpy(seven, "-F");

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

  strcpy(nine, "-S");

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

  strcpy(eleven, "-H");

  strcpy(twelve, "300");

  strcpy(thirteen, "-L");

  strcpy(fourteen, "100");

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

                   five, six, seven, eight, nine,

                   ten, eleven, twelve, thirteen, fourteen };

  EXPECT_EQ(userclk_main(15, argv), FPGA_INVALID_PARAM);

}

/**

 * @test       main6

 * @brief      Test: userclk_main

 * @details    When given valid command parameters that identify an accelerator,

 *             if neither --freq-high (-H) nor --freq-low (-L) is given,

 *             then the function prints an error

 *             and returns FPGA_INVALID_PARAM.

 */

TEST_P(userclk_c_hw_p, main6) {

  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];

  strcpy(zero, "userclk");

  strcpy(one, "--segment");

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

  strcpy(three, "-B");

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

  strcpy(five, "-D");

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

  strcpy(seven, "-F");

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

  strcpy(nine, "-S");

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

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

                   five, six, seven, eight, nine,

                   ten };

  EXPECT_EQ(userclk_main(11, argv), FPGA_INVALID_PARAM);

}

INSTANTIATE_TEST_CASE_P(userclk_c, userclk_c_hw_p,

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

class userclk_c_mock_p : public userclk_c_p{

  protected:

    userclk_c_mock_p() {};

};

/**

 * @test       main3

 * @brief      Test: userclk_main

 * @details    When given valid command parameters that identify an accelerator,

 *             if --freq-low is not given,

 *             then low is calculated from high,

 *             and the fn returns zero.

 */

TEST_P(userclk_c_mock_p, main3) {

  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 twelve[20];

  strcpy(zero, "userclk");

  strcpy(one, "--segment");

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

  strcpy(three, "-B");

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

  strcpy(five, "-D");

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

  strcpy(seven, "-F");

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

  strcpy(nine, "-S");

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

  strcpy(eleven, "-H");

  strcpy(twelve, "400");

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

                   five, six, seven, eight, nine,

                   ten, eleven, twelve };

  /*

  ** FIXME: main should return zero in this case, but

  ** the user clocks API polls on a sysfs file with a

  ** timeout. Because the sysfs file never updates in

  ** a mock environment, the API will time out and return

  ** FPGA_NOT_SUPPORTED.

  EXPECT_EQ(userclk_main(13, argv), 0);

  */

  EXPECT_EQ(userclk_main(13, argv), FPGA_NOT_SUPPORTED);

}

/**

 * @test       main4

 * @brief      Test: userclk_main

 * @details    When given valid command parameters that identify an accelerator,

 *             if --freq-high is not given,

 *             then high is calculated from low,

 *             and the fn returns zero.

 */

TEST_P(userclk_c_mock_p, main4) {

  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 twelve[20];

  strcpy(zero, "userclk");

  strcpy(one, "--segment");

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

  strcpy(three, "-B");

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

  strcpy(five, "-D");

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

  strcpy(seven, "-F");

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

  strcpy(nine, "-S");

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

  strcpy(eleven, "-L");

  strcpy(twelve, "200");

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

                   five, six, seven, eight, nine,

                   ten, eleven, twelve };

  /*

  ** FIXME: main should return zero in this case, but

  ** the user clocks API polls on a sysfs file with a

  ** timeout. Because the sysfs file never updates in

  ** a mock environment, the API will time out and return

  ** FPGA_NOT_SUPPORTED.

  EXPECT_EQ(userclk_main(13, argv), 0);

  */

  EXPECT_EQ(userclk_main(13, argv), FPGA_NOT_SUPPORTED);

}

/**

 * @test       main5

 * @brief      Test: userclk_main

 * @details    When given valid command parameters that identify an accelerator,

 *             if both --freq-high (-H) and --freq-low (-L) are given,

 *             then high must equal 2 * low,

 *             or else the fn returns FPGA_INVALID_PARAM.

 */

TEST_P(userclk_c_mock_p, main5) {

  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 twelve[20];

  char thirteen[20];

  char fourteen[20];

  strcpy(zero, "userclk");

  strcpy(one, "--segment");

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

  strcpy(three, "-B");

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

  strcpy(five, "-D");

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

  strcpy(seven, "-F");

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

  strcpy(nine, "-S");

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

  strcpy(eleven, "-H");

  strcpy(twelve, "300");

  strcpy(thirteen, "-L");

  strcpy(fourteen, "100");

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

                   five, six, seven, eight, nine,

                   ten, eleven, twelve, thirteen, fourteen };

  EXPECT_EQ(userclk_main(15, argv), FPGA_INVALID_PARAM);

}

/**

 * @test       main6

 * @brief      Test: userclk_main

 * @details    When given valid command parameters that identify an accelerator,

 *             if neither --freq-high (-H) nor --freq-low (-L) is given,

 *             then the function prints an error

 *             and returns FPGA_INVALID_PARAM.

 */

TEST_P(userclk_c_mock_p, main6) {

  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];

  strcpy(zero, "userclk");

  strcpy(one, "--segment");

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

  strcpy(three, "-B");

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

  strcpy(five, "-D");

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

  strcpy(seven, "-F");

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

  strcpy(nine, "-S");

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

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

                   five, six, seven, eight, nine,

                   ten };

  EXPECT_EQ(userclk_main(11, argv), FPGA_INVALID_PARAM);

}

INSTANTIATE_TEST_CASE_P(userclk_c, userclk_c_mock_p,

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