diff options
Diffstat (limited to 'src/gtest')
| -rw-r--r-- | src/gtest/rpc_test.cpp | 516 | ||||
| -rw-r--r-- | src/gtest/trex_stateless_gtest.cpp | 353 |
2 files changed, 785 insertions, 84 deletions
diff --git a/src/gtest/rpc_test.cpp b/src/gtest/rpc_test.cpp index 8a7e9176..168ee936 100644 --- a/src/gtest/rpc_test.cpp +++ b/src/gtest/rpc_test.cpp @@ -25,12 +25,23 @@ limitations under the License. #include <zmq.h> #include <json/json.h> #include <sstream> +#include <vector> +#include <algorithm> using namespace std; class RpcTest : public testing::Test { +protected: + + void set_verbose(bool verbose) { + m_verbose = verbose; + } + virtual void SetUp() { + + m_verbose = false; + TrexRpcServerConfig cfg = TrexRpcServerConfig(TrexRpcServerConfig::RPC_PROT_TCP, 5050); m_rpc = new TrexRpcServer(cfg); @@ -39,6 +50,7 @@ class RpcTest : public testing::Test { m_context = zmq_ctx_new (); m_socket = zmq_socket (m_context, ZMQ_REQ); zmq_connect (m_socket, "tcp://localhost:5050"); + } virtual void TearDown() { @@ -50,8 +62,41 @@ class RpcTest : public testing::Test { } public: + + void create_request(Json::Value &request, const string &method, int id = 1) { + request.clear(); + + request["jsonrpc"] = "2.0"; + request["id"] = id; + request["method"] = method; + + } + + void send_request(const Json::Value &request, Json::Value &response) { + Json::FastWriter writer; + Json::Reader reader; + + response.clear(); + + string request_str = writer.write(request); + + if (m_verbose) { + cout << "\n" << request_str << "\n"; + } + + string ret = send_msg(request_str); + + if (m_verbose) { + cout << "\n" << ret << "\n"; + } + + EXPECT_TRUE(reader.parse(ret, response, false)); + EXPECT_EQ(response["jsonrpc"], "2.0"); + EXPECT_EQ(response["id"], request["id"]); + } + string send_msg(const string &msg) { - char buffer[512]; + char buffer[1024 * 20]; zmq_send (m_socket, msg.c_str(), msg.size(), 0); int len = zmq_recv(m_socket, buffer, sizeof(buffer), 0); @@ -62,9 +107,64 @@ public: TrexRpcServer *m_rpc; void *m_context; void *m_socket; + bool m_verbose; }; -TEST_F(RpcTest, basic_rpc_test) { +class RpcTestOwned : public RpcTest { +public: + + void create_request(Json::Value &request, const string &method, int id = 1, int port_id = 1, bool owned = true) { + RpcTest::create_request(request, method, id); + if (owned) { + request["params"]["port_id"] = port_id; + request["params"]["handler"] = m_ownership_handler[port_id]; + } + } + +protected: + + virtual void SetUp() { + RpcTest::SetUp(); + + for (int i = 0 ; i < 4; i++) { + m_ownership_handler[i] = take_ownership(i); + } + } + + + string take_ownership(uint8_t port_id) { + Json::Value request; + Json::Value response; + + RpcTest::create_request(request, "acquire", 1); + + request["params"]["port_id"] = port_id; + request["params"]["user"] = "test"; + request["params"]["force"] = true; + + send_request(request, response); + + EXPECT_TRUE(response["result"] != Json::nullValue); + return response["result"].asString(); + } + + void release_ownership(uint8_t port_id) { + Json::Value request; + Json::Value response; + + RpcTest::create_request(request, "release", 1); + + request["params"]["handler"] = m_ownership_handler; + request["params"]["port_id"] = port_id; + + send_request(request, response); + EXPECT_TRUE(response["result"] == "ACK"); + } + + string m_ownership_handler[4]; +}; + +TEST_F(RpcTest, basic_rpc_negative_cases) { Json::Value request; Json::Value response; Json::Reader reader; @@ -121,55 +221,39 @@ TEST_F(RpcTest, basic_rpc_test) { TEST_F(RpcTest, test_add_command) { Json::Value request; Json::Value response; - Json::Reader reader; - string req_str; - string resp_str; - - /* simple add - missing paramters */ - req_str = "{\"jsonrpc\": \"2.0\", \"method\": \"test_add\", \"id\": 488}"; - resp_str = send_msg(req_str); + /* missing parameters */ + create_request(request, "test_add"); + send_request(request, response); - EXPECT_TRUE(reader.parse(resp_str, response, false)); EXPECT_EQ(response["jsonrpc"], "2.0"); - EXPECT_EQ(response["id"], 488); EXPECT_EQ(response["error"]["code"], -32602); - /* simple add that works */ - req_str = "{\"jsonrpc\": \"2.0\", \"method\": \"test_add\", \"params\": {\"x\": 17, \"y\": -13} , \"id\": \"itay\"}"; - resp_str = send_msg(req_str); - - EXPECT_TRUE(reader.parse(resp_str, response, false)); - EXPECT_EQ(response["jsonrpc"], "2.0"); - EXPECT_EQ(response["id"], "itay"); - EXPECT_EQ(response["result"], 4); - - /* add with bad paratemers types */ - req_str = "{\"jsonrpc\": \"2.0\", \"method\": \"test_add\", \"params\": {\"x\": \"blah\", \"y\": -13} , \"id\": 17}"; - resp_str = send_msg(req_str); + /* bad paramters */ + create_request(request, "test_add"); + request["params"]["x"] = 5; + request["params"]["y"] = "itay"; + send_request(request, response); - EXPECT_TRUE(reader.parse(resp_str, response, false)); EXPECT_EQ(response["jsonrpc"], "2.0"); - EXPECT_EQ(response["id"], 17); EXPECT_EQ(response["error"]["code"], -32602); - /* add with invalid count of parameters */ - req_str = "{\"jsonrpc\": \"2.0\", \"method\": \"test_add\", \"params\": {\"y\": -13} , \"id\": 17}"; - resp_str = send_msg(req_str); + /* simple add that works */ + create_request(request, "test_add"); + request["params"]["x"] = 5; + request["params"]["y"] = -13; + send_request(request, response); - EXPECT_TRUE(reader.parse(resp_str, response, false)); EXPECT_EQ(response["jsonrpc"], "2.0"); - EXPECT_EQ(response["id"], 17); - EXPECT_EQ(response["error"]["code"], -32602); - + EXPECT_EQ(response["result"], -8); /* big numbers */ - req_str = "{\"jsonrpc\": \"2.0\", \"method\": \"test_add\", \"params\": {\"x\": 4827371, \"y\": -39181273} , \"id\": \"itay\"}"; - resp_str = send_msg(req_str); + create_request(request, "test_add"); + request["params"]["x"] = 4827371; + request["params"]["y"] = -39181273; + send_request(request, response); - EXPECT_TRUE(reader.parse(resp_str, response, false)); EXPECT_EQ(response["jsonrpc"], "2.0"); - EXPECT_EQ(response["id"], "itay"); EXPECT_EQ(response["result"], -34353902); } @@ -225,87 +309,351 @@ TEST_F(RpcTest, batch_rpc_test) { return; } -TEST_F(RpcTest, add_stream) { +/* ping command */ +TEST_F(RpcTest, ping) { Json::Value request; Json::Value response; - Json::Reader reader; - string resp_str; + create_request(request, "ping"); + send_request(request, response); + EXPECT_TRUE(response["result"] == "ACK"); +} + +static bool +find_member_in_array(const Json::Value &array, const string &member) { + for (auto x : array) { + if (x == member) { + return true; + } + } - // check the stream does not exists - string lookup_str = "{\"jsonrpc\":\"2.0\", \"id\":1, \"method\":\"get_stream\", \"params\":{\"port_id\":1, \"stream_id\":5}}"; - resp_str = send_msg(lookup_str); + return false; +} + +/* get registered commands */ +TEST_F(RpcTest, get_supported_cmds) { + Json::Value request; + Json::Value response; + + create_request(request, "get_supported_cmds"); + send_request(request, response); + EXPECT_TRUE(response["result"].size() > 0); + + EXPECT_TRUE(find_member_in_array(response["result"], "ping")); + EXPECT_TRUE(find_member_in_array(response["result"], "get_supported_cmds")); +} + +/* get version */ +TEST_F(RpcTest, get_version) { + Json::Value request; + Json::Value response; + + create_request(request, "get_version"); + send_request(request, response); + + EXPECT_TRUE(response["result"] != Json::nullValue); + EXPECT_TRUE(response["result"]["built_by"] == "MOCK"); + EXPECT_TRUE(response["result"]["version"] == "v0.0"); +} + +/* get system info */ +TEST_F(RpcTest, get_system_info) { + Json::Value request; + Json::Value response; + + create_request(request, "get_system_info"); + send_request(request, response); + + EXPECT_TRUE(response["result"] != Json::nullValue); + EXPECT_TRUE(response["result"]["core_type"].isString()); + EXPECT_TRUE(response["result"]["hostname"].isString()); + EXPECT_TRUE(response["result"]["uptime"].isString()); + EXPECT_TRUE(response["result"]["dp_core_count"] > 0); + EXPECT_TRUE(response["result"]["port_count"] > 0); + + EXPECT_TRUE(response["result"]["ports"].isArray()); + + const Json::Value &ports = response["result"]["ports"]; + + + for (int i = 0; i < ports.size(); i++) { + EXPECT_TRUE(ports[i]["index"] == i); + EXPECT_TRUE(ports[i]["driver"].isString()); + EXPECT_TRUE(ports[i]["speed"].isString()); + } +} + +/* get owner, acquire and release */ +TEST_F(RpcTest, get_owner_acquire_release) { + Json::Value request; + Json::Value response; + + /* no user before acquring */ + create_request(request, "get_owner"); + request["params"]["port_id"] = 1; + send_request(request, response); + EXPECT_TRUE(response["result"] != Json::nullValue); + + EXPECT_TRUE(response["result"]["owner"] == "none"); + + /* soft acquire */ + create_request(request, "acquire"); + request["params"]["port_id"] = 1; + request["params"]["user"] = "itay"; + request["params"]["force"] = false; + + send_request(request, response); + EXPECT_TRUE(response["result"] != Json::nullValue); + + create_request(request, "get_owner"); + request["params"]["port_id"] = 1; + send_request(request, response); + EXPECT_TRUE(response["result"] != Json::nullValue); + + EXPECT_TRUE(response["result"]["owner"] == "itay"); + + /* hard acquire */ + create_request(request, "acquire"); + request["params"]["port_id"] = 1; + request["params"]["user"] = "moshe"; + request["params"]["force"] = false; + + send_request(request, response); + EXPECT_TRUE(response["result"] == Json::nullValue); + + request["params"]["force"] = true; + + send_request(request, response); + EXPECT_TRUE(response["result"] != Json::nullValue); + + string handler = response["result"].asString(); + + /* make sure */ + create_request(request, "get_owner"); + request["params"]["port_id"] = 1; + send_request(request, response); + EXPECT_TRUE(response["result"] != Json::nullValue); + + EXPECT_TRUE(response["result"]["owner"] == "moshe"); + + /* release */ + create_request(request, "release"); + request["params"]["port_id"] = 1; + request["params"]["handler"] = handler; + send_request(request, response); + + EXPECT_TRUE(response["result"] == "ACK"); +} + + +static void +create_simple_stream(Json::Value &obj) { + obj["mode"]["type"] = "continuous"; + obj["mode"]["pps"] = (rand() % 1000 + 1) * 0.99; + obj["isg"] = (rand() % 100 + 1) * 0.99;; + obj["enabled"] = true; + obj["self_start"] = true; + obj["next_stream_id"] = -1; + + obj["packet"]["meta"] = "dummy"; + + int packet_size = (rand() % 1500 + 1); + for (int i = 0; i < packet_size; i++) { + obj["packet"]["binary"][i] = (rand() % 0xff); + } + + obj["vm"] = Json::arrayValue; + obj["rx_stats"]["enabled"] = false; +} + +static bool +compare_streams(const Json::Value &s1, const Json::Value &s2) { + return s1 == s2; +} + +TEST_F(RpcTestOwned, add_remove_stream) { + Json::Value request; + Json::Value response; + + /* verify no such stream */ + create_request(request, "get_stream", 1, 1); + + request["params"]["stream_id"] = 5; + + send_request(request, response); - EXPECT_TRUE(reader.parse(resp_str, response, false)); EXPECT_EQ(response["jsonrpc"], "2.0"); EXPECT_EQ(response["id"], 1); + EXPECT_EQ(response["error"]["code"], -32000); + + /* add it */ + create_request(request, "add_stream", 1, 1); + request["params"]["stream_id"] = 5; + + Json::Value stream; + create_simple_stream(stream); + + request["params"]["stream"] = stream; + send_request(request, response); + + EXPECT_EQ(response["result"], "ACK"); + + /* get it */ + create_request(request, "get_stream", 1, 1); + + request["params"]["stream_id"] = 5; + + send_request(request, response); + + EXPECT_TRUE(compare_streams(stream, response["result"]["stream"])); + + // remove it + create_request(request, "remove_stream", 1, 1); + + request["params"]["stream_id"] = 5; + + send_request(request, response); + + EXPECT_EQ(response["result"], "ACK"); + + // should not be present anymore + send_request(request, response); EXPECT_EQ(response["error"]["code"], -32000); - // add it +} - string add_str = "{\"jsonrpc\":\"2.0\", \"id\":1, \"method\":\"add_stream\", \"params\":" - "{\"port_id\":1, \"stream_id\":5, \"stream\":{" - "\"mode\": {\"type\":\"continuous\", \"pps\":3}," - "\"isg\":4.3, \"enabled\":true, \"self_start\":true," - "\"next_stream_id\":-1," - "\"packet\":{\"binary\":[4,1,255], \"meta\":\"dummy\"}," - "\"vm\":[]," - "\"rx_stats\":{\"enabled\":false}}}}"; - resp_str = send_msg(add_str); +TEST_F(RpcTestOwned, get_stream_id_list) { + Json::Value request; + Json::Value response; + + /* add stream 1 */ + create_request(request, "add_stream", 1); + request["params"]["port_id"] = 1; - EXPECT_TRUE(reader.parse(resp_str, response, false)); - EXPECT_EQ(response["jsonrpc"], "2.0"); - EXPECT_EQ(response["id"], 1); + Json::Value stream; + create_simple_stream(stream); + + request["params"]["stream"] = stream; + request["params"]["stream_id"] = 5; + send_request(request, response); EXPECT_EQ(response["result"], "ACK"); - resp_str = send_msg(lookup_str); + request["params"]["stream_id"] = 12; + send_request(request, response); + EXPECT_EQ(response["result"], "ACK"); - EXPECT_TRUE(reader.parse(resp_str, response, false)); - EXPECT_EQ(response["jsonrpc"], "2.0"); - EXPECT_EQ(response["id"], 1); + request["params"]["stream_id"] = 19; + send_request(request, response); + EXPECT_EQ(response["result"], "ACK"); - const Json::Value &stream = response["result"]["stream"]; - EXPECT_EQ(stream["enabled"], true); - EXPECT_EQ(stream["self_start"], true); + create_request(request, "get_stream_list"); + request["params"]["port_id"] = 1; + send_request(request, response); - EXPECT_EQ(stream["packet"]["binary"][0], 4); - EXPECT_EQ(stream["packet"]["binary"][1], 1); - EXPECT_EQ(stream["packet"]["binary"][2], 255); + EXPECT_TRUE(response["result"].isArray()); + vector<int> vec; + for (auto x : response["result"]) { + vec.push_back(x.asInt()); + } - EXPECT_EQ(stream["packet"]["meta"], "dummy"); - EXPECT_EQ(stream["next_stream_id"], -1); + sort(vec.begin(), vec.end()); - double delta = stream["isg"].asDouble() - 4.3; - EXPECT_TRUE(delta < 0.0001); + EXPECT_EQ(vec[0], 5); + EXPECT_EQ(vec[1], 12); + EXPECT_EQ(vec[2], 19); - EXPECT_EQ(stream["mode"]["type"], "continuous"); - EXPECT_EQ(stream["mode"]["pps"], 3); + create_request(request, "remove_all_streams"); + request["params"]["port_id"] = 1; + send_request(request, response); - // remove it + EXPECT_TRUE(response["result"] == "ACK"); - string remove_str = "{\"jsonrpc\":\"2.0\", \"id\":1, \"method\":\"remove_stream\", \"params\":{\"port_id\":1, \"stream_id\":5}}"; - resp_str = send_msg(remove_str); + /* make sure the lights are off ... */ + create_request(request, "get_stream_list"); + request["params"]["port_id"] = 1; + send_request(request, response); - EXPECT_TRUE(reader.parse(resp_str, response, false)); - EXPECT_EQ(response["jsonrpc"], "2.0"); - EXPECT_EQ(response["id"], 1); + EXPECT_TRUE(response["result"].isArray()); + EXPECT_TRUE(response["result"].size() == 0); +} + + +TEST_F(RpcTestOwned, start_stop_traffic) { + Json::Value request; + Json::Value response; + /* add stream #1 */ + create_request(request, "add_stream", 1, 1); + request["params"]["stream_id"] = 5; + + Json::Value stream; + create_simple_stream(stream); + + request["params"]["stream"] = stream; + + send_request(request, response); EXPECT_EQ(response["result"], "ACK"); - resp_str = send_msg(remove_str); + /* add stream #1 */ + create_request(request, "add_stream", 1, 3); + request["params"]["stream_id"] = 12; + request["params"]["stream"] = stream; + + send_request(request, response); + EXPECT_EQ(response["result"], "ACK"); - // should not be present anymore + /* start port 1 */ + create_request(request, "start_traffic", 1, 1); + send_request(request, response); + EXPECT_EQ(response["result"], "ACK"); - EXPECT_TRUE(reader.parse(resp_str, response, false)); - EXPECT_EQ(response["jsonrpc"], "2.0"); - EXPECT_EQ(response["id"], 1); + /* start port 3 */ + create_request(request, "start_traffic", 1, 3); + send_request(request, response); + EXPECT_EQ(response["result"], "ACK"); + + /* start not configured port */ + create_request(request, "start_traffic", 1, 2); + send_request(request, response); EXPECT_EQ(response["error"]["code"], -32000); -} + /* stop port 1 */ + create_request(request, "stop_traffic", 1, 1); + send_request(request, response); + EXPECT_EQ(response["result"], "ACK"); + /* stop port 3 */ + create_request(request, "stop_traffic", 1, 3); + send_request(request, response); + EXPECT_EQ(response["result"], "ACK"); + + /* start 1 again */ + create_request(request, "start_traffic", 1, 1); + send_request(request, response); + EXPECT_EQ(response["result"], "ACK"); + /* start 1 twice (error) */ + create_request(request, "start_traffic", 1, 1); + send_request(request, response); + EXPECT_EQ(response["error"]["code"], -32000); + + /* make sure you cannot release while traffic is active */ + create_request(request, "release", 1, 1); + send_request(request, response); + EXPECT_EQ(response["error"]["code"], -32000); + + /* stop traffic on port #1 */ + create_request(request, "stop_traffic",1 ,1); + send_request(request, response); + EXPECT_EQ(response["result"], "ACK"); + + /* release */ + create_request(request, "release", 1, 1); + send_request(request, response); + EXPECT_EQ(response["result"], "ACK"); +} diff --git a/src/gtest/trex_stateless_gtest.cpp b/src/gtest/trex_stateless_gtest.cpp new file mode 100644 index 00000000..0341516c --- /dev/null +++ b/src/gtest/trex_stateless_gtest.cpp @@ -0,0 +1,353 @@ +/* + Hanoh Haim + Cisco Systems, Inc. +*/ + +/* +Copyright (c) 2015-2015 Cisco Systems, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#include "bp_sim.h" +#include <common/gtest.h> +#include <common/basic_utils.h> + + +#define EXPECT_EQ_UINT32(a,b) EXPECT_EQ((uint32_t)(a),(uint32_t)(b)) + +// one stream info with const packet , no VM +class CTRexDpStatelessVM { + +}; + +//- add dump function +// - check one object +// create frame work + +class CTRexDpStreamModeContinues{ +public: + void set_pps(double pps){ + m_pps=pps; + } + double get_pps(){ + return (m_pps); + } + + void dump(FILE *fd); +private: + double m_pps; +}; + + +void CTRexDpStreamModeContinues::dump(FILE *fd){ + fprintf (fd," pps : %f \n",m_pps); +} + + +class CTRexDpStreamModeSingleBurst{ +public: + void set_pps(double pps){ + m_pps=pps; + } + double get_pps(){ + return (m_pps); + } + + void set_total_packets(uint64_t total_packets){ + m_total_packets =total_packets; + } + + uint64_t get_total_packets(){ + return (m_total_packets); + } + + void dump(FILE *fd); + +private: + double m_pps; + uint64_t m_total_packets; +}; + + +void CTRexDpStreamModeSingleBurst::dump(FILE *fd){ + fprintf (fd," pps : %f \n",m_pps); + fprintf (fd," total_packets : %llu \n",m_total_packets); +} + + +class CTRexDpStreamModeMultiBurst{ +public: + void set_pps(double pps){ + m_pps=pps; + } + double get_pps(){ + return (m_pps); + } + + void set_pkts_per_burst(uint64_t pkts_per_burst){ + m_pkts_per_burst =pkts_per_burst; + } + + uint64_t get_pkts_per_burst(){ + return (m_pkts_per_burst); + } + + void set_ibg(double ibg){ + m_ibg = ibg; + } + + double get_ibg(){ + return ( m_ibg ); + } + + void set_number_of_bursts(uint32_t number_of_bursts){ + m_number_of_bursts = number_of_bursts; + } + + uint32_t get_number_of_bursts(){ + return (m_number_of_bursts); + } + + void dump(FILE *fd); + +private: + double m_pps; + double m_ibg; // inter burst gap + uint64_t m_pkts_per_burst; + uint32_t m_number_of_bursts; +}; + +void CTRexDpStreamModeMultiBurst::dump(FILE *fd){ + fprintf (fd," pps : %f \n",m_pps); + fprintf (fd," total_packets : %llu \n",m_pkts_per_burst); + fprintf (fd," ibg : %f \n",m_ibg); + fprintf (fd," num_of_bursts : %llu \n",m_number_of_bursts); +} + + + +class CTRexDpStreamMode { +public: + enum MODES { + moCONTINUES = 0x0, + moSINGLE_BURST = 0x1, + moMULTI_BURST = 0x2 + } ; + typedef uint8_t MODE_TYPE_t; + + void reset(); + + void set_mode(MODE_TYPE_t mode ){ + m_type = mode; + } + + MODE_TYPE_t get_mode(){ + return (m_type); + } + + + CTRexDpStreamModeContinues & cont(void){ + return (m_data.m_cont); + } + CTRexDpStreamModeSingleBurst & single_burst(void){ + return (m_data.m_signle_burst); + } + + CTRexDpStreamModeMultiBurst & multi_burst(void){ + return (m_data.m_multi_burst); + } + + void dump(FILE *fd); + +private: + uint8_t m_type; + union Data { + CTRexDpStreamModeContinues m_cont; + CTRexDpStreamModeSingleBurst m_signle_burst; + CTRexDpStreamModeMultiBurst m_multi_burst; + } m_data; +}; + + +void CTRexDpStreamMode::reset(){ + m_type =CTRexDpStreamMode::moCONTINUES; + memset(&m_data,0,sizeof(m_data)); +} + +void CTRexDpStreamMode::dump(FILE *fd){ + const char * table[3] = {"CONTINUES","SINGLE_BURST","MULTI_BURST"}; + + fprintf(fd," mode : %s \n", (char*)table[m_type]); + switch (m_type) { + case CTRexDpStreamMode::moCONTINUES : + cont().dump(fd); + break; + case CTRexDpStreamMode::moSINGLE_BURST : + single_burst().dump(fd); + break; + case CTRexDpStreamMode::moMULTI_BURST : + multi_burst().dump(fd); + break; + default: + fprintf(fd," ERROR type if not valid %d \n",m_type); + break; + } +} + + + + +class CTRexDpStatelessStream { + +public: + enum FLAGS_0{ + _ENABLE = 0, + _SELF_START = 1, + _VM_ENABLE =2, + _END_STREAM =-1 + }; + + CTRexDpStatelessStream(){ + reset(); + } + + void reset(){ + m_packet =0; + m_vm=0; + m_flags=0; + m_isg_sec=0.0; + m_next_stream = CTRexDpStatelessStream::_END_STREAM ; // END + m_mode.reset(); + } + + void set_enable(bool enable){ + btSetMaskBit32(m_flags,_ENABLE,_ENABLE,enable?1:0); + } + + bool get_enabled(){ + return (btGetMaskBit32(m_flags,_ENABLE,_ENABLE)?true:false); + } + + void set_self_start(bool enable){ + btSetMaskBit32(m_flags,_SELF_START,_SELF_START,enable?1:0); + } + + bool get_self_start(bool enable){ + return (btGetMaskBit32(m_flags,_SELF_START,_SELF_START)?true:false); + } + + + /* if we don't have VM we could just replicate the mbuf and allocate it once */ + void set_vm_enable(bool enable){ + btSetMaskBit32(m_flags,_VM_ENABLE,_VM_ENABLE,enable?1:0); + } + + bool get_vm_enabled(bool enable){ + return (btGetMaskBit32(m_flags,_VM_ENABLE,_VM_ENABLE)?true:false); + } + + void set_inter_stream_gap(double isg_sec){ + m_isg_sec =isg_sec; + } + + double get_inter_stream_gap(){ + return (m_isg_sec); + } + + CTRexDpStreamMode & get_mode(); + + + // CTRexDpStatelessStream::_END_STREAM for END + void set_next_stream(int32_t next_stream){ + m_next_stream =next_stream; + } + + int32_t get_next_stream(void){ + return ( m_next_stream ); + } + + void dump(FILE *fd); + +private: + char * m_packet; + CTRexDpStatelessVM * m_vm; + uint32_t m_flags; + double m_isg_sec; // in second + CTRexDpStreamMode m_mode; + int32_t m_next_stream; // next stream id +}; + +//- list of streams info with const packet , no VM +// - object that include the stream /scheduler/ packet allocation / need to create an object for one thread that works for test +// generate pcap file and compare it + +#if 0 +void CTRexDpStatelessStream::dump(FILE *fd){ + + fprintf(fd," enabled : %d \n",get_enabled()?1:0); + fprintf(fd," self_start : %d \n",get_self_start()?1:0); + fprintf(fd," vm : %d \n",get_vm_enabled()?1:0); + fprintf(" isg : %f \n",m_isg_sec); + m_mode.dump(fd); + if (m_next_stream == CTRexDpStatelessStream::_END_STREAM ) { + fprintf(fd," action : End of Stream \n"); + }else{ + fprintf(" next : %d \n",m_next_stream); + } +} + + + +class CTRexStatelessBasic { + +public: + CTRexStatelessBasic(){ + m_threads=1; + } + + bool init(void){ + return (true); + } + +public: + bool m_threads; +}; + + +/* stateless basic */ +class dp_sl_basic : public testing::Test { + protected: + virtual void SetUp() { + } + virtual void TearDown() { + } +public: +}; + + + +TEST_F(dp_sl_basic, test1) { + CTRexDpStatelessStream s1; + s1.set_enable(true); + s1.set_self_start(true); + s1.set_inter_stream_gap(0.77); + s1.get_mode().set_mode(CTRexDpStreamMode::moCONTINUES); + s1.get_mode().cont().set_pps(100.2); + s1.dump(stdout); +} + + + + +#endif |