From 490782918c6264e3e7e0204b5d0e70574b9b0dc5 Mon Sep 17 00:00:00 2001 From: Wonsup Yoon Date: Thu, 20 Jan 2022 18:46:10 +0900 Subject: [PATCH 1/2] Generated from commit e8cbe2527fc127541ebc3e5baaac1f7b1739dec5 --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 0c5866778..68c3634ff 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,7 @@ # KENSv3 (KAIST Educational Network System) +[![Test Linux Environment](https://github.com/ANLAB-KAIST/KENSv3/actions/workflows/test-linux.yml/badge.svg)](https://github.com/ANLAB-KAIST/KENSv3/actions/workflows/test-linux.yml) [![Test Linux Extra Environments](https://github.com/ANLAB-KAIST/KENSv3/actions/workflows/test-linux-extra.yml/badge.svg)](https://github.com/ANLAB-KAIST/KENSv3/actions/workflows/test-linux-extra.yml) [![Test WSL Environment](https://github.com/ANLAB-KAIST/KENSv3/actions/workflows/test-wsl.yml/badge.svg)](https://github.com/ANLAB-KAIST/KENSv3/actions/workflows/test-wsl.yml) [![Test macOS Environment](https://github.com/ANLAB-KAIST/KENSv3/actions/workflows/test-macos.yml/badge.svg)](https://github.com/ANLAB-KAIST/KENSv3/actions/workflows/test-macos.yml) + KENS series have been used for programming assignment in CS341: Introduction to Computer Network in KAIST. First version of KENS (v1) had been developed by Network Computing Lab, 2005. This version had been used until 2013. From 00a03e7e86fe22a20e13e043f9ea46c82b4f923b Mon Sep 17 00:00:00 2001 From: Wonsup Yoon Date: Mon, 14 Mar 2022 21:19:48 +0900 Subject: [PATCH 2/2] Generated from commit 7568e87865794c26cc44337d08debdb91551edf6 --- app/echo/CMakeLists.txt | 11 + app/echo/EchoAssignment.cpp | 84 +++++ app/echo/EchoAssignment.hpp | 59 ++++ app/echo/EchoNonKens.cpp | 15 + app/echo/testecho.cpp | 662 ++++++++++++++++++++++++++++++++++++ 5 files changed, 831 insertions(+) create mode 100644 app/echo/CMakeLists.txt create mode 100644 app/echo/EchoAssignment.cpp create mode 100644 app/echo/EchoAssignment.hpp create mode 100644 app/echo/EchoNonKens.cpp create mode 100644 app/echo/testecho.cpp diff --git a/app/echo/CMakeLists.txt b/app/echo/CMakeLists.txt new file mode 100644 index 000000000..18944761b --- /dev/null +++ b/app/echo/CMakeLists.txt @@ -0,0 +1,11 @@ +project(echo) + +set(echo_SOURCES EchoAssignment.cpp EchoAssignment.hpp) + +add_executable(echo ${echo_SOURCES} testecho.cpp) +add_executable(echo-non-kens ${echo_SOURCES} EchoNonKens.cpp) + +get_solution(kens) + +target_link_libraries(echo kens kens_solution gtest_main) +target_compile_definitions(echo-non-kens PRIVATE NON_KENS) diff --git a/app/echo/EchoAssignment.cpp b/app/echo/EchoAssignment.cpp new file mode 100644 index 000000000..e1872ee20 --- /dev/null +++ b/app/echo/EchoAssignment.cpp @@ -0,0 +1,84 @@ +#include "EchoAssignment.hpp" + +#include +#include +#include + +#include + +// !IMPORTANT: allowed system calls. +// !DO NOT USE OTHER NETWORK SYSCALLS (send, recv, select, poll, epoll, fork +// etc.) +// * socket +// * bind +// * listen +// * accept +// * read +// * write +// * close +// * getsockname +// * getpeername +// See below for their usage. +// https://github.com/ANLAB-KAIST/KENSv3/wiki/Misc:-External-Resources#linux-manuals + +int EchoAssignment::serverMain(const char *bind_ip, int port, + const char *server_hello) { + // Your server code + // !IMPORTANT: do not use global variables and do not define/use functions + // !IMPORTANT: for all system calls, when an error happens, your program must + // return. e.g., if an read() call return -1, return -1 for serverMain. + + return 0; +} + +int EchoAssignment::clientMain(const char *server_ip, int port, + const char *command) { + // Your client code + // !IMPORTANT: do not use global variables and do not define/use functions + // !IMPORTANT: for all system calls, when an error happens, your program must + // return. e.g., if an read() call return -1, return -1 for clientMain. + + return 0; +} + +static void print_usage(const char *program) { + printf("Usage: %s \n" + "Modes:\n c: client\n s: server\n" + "Client commands:\n" + " hello : server returns \n" + " whoami: server returns \n" + " whoru : server returns \n" + " others: server echos\n" + "Note: each command is terminated by newline character (\\n)\n" + "Examples:\n" + " server: %s s 0.0.0.0 9000 hello-client\n" + " client: %s c 127.0.0.1 9000 whoami\n", + program, program, program); +} + +int EchoAssignment::Main(int argc, char *argv[]) { + + if (argc == 0) + return 1; + + if (argc != 5) { + print_usage(argv[0]); + return 1; + } + + int port = atoi(argv[3]); + if (port == 0) { + printf("Wrong port number\n"); + print_usage(argv[0]); + } + + switch (*argv[1]) { + case 'c': + return clientMain(argv[2], port, argv[4]); + case 's': + return serverMain(argv[2], port, argv[4]); + default: + print_usage(argv[0]); + return 1; + } +} diff --git a/app/echo/EchoAssignment.hpp b/app/echo/EchoAssignment.hpp new file mode 100644 index 000000000..be2e0d605 --- /dev/null +++ b/app/echo/EchoAssignment.hpp @@ -0,0 +1,59 @@ +#ifndef E_ECHOASSIGNMENT_HPP_ +#define E_ECHOASSIGNMENT_HPP_ + +#ifndef NON_KENS + +#include +#include +#include + +#include + +#else + +#include +#include + +namespace E { +class Host {}; +class TCPApplication { +public: + TCPApplication(Host &host) {} +}; +} // namespace E + +#endif + +#include +#include +#include + +using namespace E; + +class EchoTesting; +class EchoAssignment : public TCPApplication { +public: + EchoAssignment(Host &host, std::map &answers, + int argc, char *argv[]) + : TCPApplication(host), ___answers(answers), argc(argc), argv(argv) {} + + int serverMain(const char *bind_ip, int port, const char *server_hello); + int clientMain(const char *server_ip, int port, const char *msg); + int Main(int argc, char *argv[]); + + int E_Main() { return Main(argc, argv); } + +private: + int argc; + char **argv; + std::map &___answers; + + // ip: peer(client or server)'s IP address + // answer: peer's request/response + void submitAnswer(const char *ip, const char *answer) { + ___answers[ip] = answer; + } + friend class EchoTesting; +}; + +#endif \ No newline at end of file diff --git a/app/echo/EchoNonKens.cpp b/app/echo/EchoNonKens.cpp new file mode 100644 index 000000000..835b1a1d6 --- /dev/null +++ b/app/echo/EchoNonKens.cpp @@ -0,0 +1,15 @@ + +#include "EchoAssignment.hpp" + +int main(int argc, char *argv[]) { + Host host; + std::map answers; + EchoAssignment assignment(host, answers, argc, argv); + + int ret = assignment.E_Main(); + printf("Submitted answers:\n"); + for (auto &answer : answers) { + printf(" %s -> %s\n", answer.first.c_str(), answer.second.c_str()); + } + return ret; +} \ No newline at end of file diff --git a/app/echo/testecho.cpp b/app/echo/testecho.cpp new file mode 100644 index 000000000..bf40b8117 --- /dev/null +++ b/app/echo/testecho.cpp @@ -0,0 +1,662 @@ + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "EchoAssignment.hpp" + +#include + +using namespace E; + +struct EchoHost { + std::shared_ptr host; + + struct EchoApp { + int pid; + std::map answers; + std::vector args; + EchoApp(std::initializer_list arg_list) { + for (const char *arg : arg_list) { + char *arg_c = strdup(arg); + args.push_back(arg_c); + } + } + ~EchoApp() { + for (size_t i = 0; i < args.size(); ++i) { + free(args[i]); + } + } + EchoApp(EchoApp &&other) + : pid(other.pid), answers(std::move(other.answers)) { + for (size_t i = 0; i < other.args.size(); ++i) { + args.push_back(other.args[i]); + } + other.args.resize(0); + } + + EchoApp &operator=(EchoApp &&other) { + pid = other.pid; + answers = std::move(other.answers); + for (size_t i = 0; i < other.args.size(); ++i) { + args.push_back(other.args[i]); + } + other.args.resize(0); + return *this; + } + EchoApp(const EchoApp &other) = delete; + EchoApp &operator=(const EchoApp &other) = delete; + }; + + std::vector apps; +}; + +class EchoTesting : public ::testing::Test { +protected: + NetworkSystem netSystem; + std::vector hosts; + std::shared_ptr switchingHub; + + std::vector servers; + std::vector> connections; + + void SetUp(std::initializer_list __servers, + const uint8_t num_clients, + std::initializer_list> + __connections) { + servers = __servers; + + assert(servers.size() < 50); + uint8_t num_servers = servers.size(); + assert(num_clients < 150); + + const uint8_t num_hosts = num_clients + num_servers; + + switchingHub = netSystem.addModule("Switch0", netSystem); + for (uint8_t host_id = 1; host_id <= num_hosts; ++host_id) { + std::string host_name = "TestHost_" + std::to_string(host_id); + + EchoHost host; + host.host = netSystem.addModule(host_name, netSystem); + + mac_t mac{0xBC, 0xBC, 0xBC, 0xBC, 0xBC, host_id}; + ipv4_t ip{10, 0, 0, host_id}; + auto wire = netSystem + .addWire(*host.host, *switchingHub, + TimeUtil::makeTime(1, TimeUtil::MSEC)) + .second; + + host.host->setMACAddr(mac, wire.first); + + for (uint8_t peer_id = 1; peer_id <= num_hosts; ++peer_id) { + if (peer_id == host_id) + continue; + + mac_t peer_mac{0xBC, 0xBC, 0xBC, 0xBC, 0xBC, peer_id}; + ipv4_t peer_ip{10, 0, 0, peer_id}; + host.host->setARPTable(peer_mac, peer_ip); + } + host.host->setIPAddr(ip, wire.first); + host.host->setRoutingTable({10, 0, 0, 0}, 16, wire.first); + + switchingHub->addMACEntry(wire.second, mac); + host.host->addHostModule(*host.host); + host.host->addHostModule(*host.host); + + TCPSolutionProvider::allocate(*host.host); + + hosts.push_back(std::move(host)); + } + const ::testing::TestInfo *const test_info = + ::testing::UnitTest::GetInstance()->current_test_info(); + std::string file_name(test_info->name()); + file_name.append(".pcap"); + switchingHub->enablePCAPLogging(file_name); + + for (auto &host : hosts) { + host.host->initializeHostModule("TCP"); + } + + for (uint8_t server_id = 0; server_id < num_servers; ++server_id) { + auto args = {"echo", "s", "0.0.0.0", "9000", servers[server_id]}; + hosts[server_id].apps.emplace_back(args); + } + + for (auto &connection : __connections) { + uint8_t server_id = std::get<0>(connection); + uint8_t client_id = std::get<1>(connection); + const char *command = std::get<2>(connection); + assert(server_id < num_servers); + assert(client_id < num_clients); + + auto &client = hosts[num_servers + client_id]; + + std::string server_ip = "10.0.0." + std::to_string(server_id + 1); + auto args = {"echo", "c", server_ip.c_str(), "9000", command}; + connections.emplace_back(server_id, client_id, command, + client.apps.size()); + client.apps.emplace_back(args); + } + } + void runTest() { + + // launch apps + for (auto &host : hosts) { + for (auto &app : host.apps) { + app.pid = host.host->addApplication( + *host.host, app.answers, app.args.size(), app.args.data()); + host.host->launchApplication(app.pid); + } + } + + netSystem.run(TimeUtil::makeTime(1000, TimeUtil::SEC)); + for (auto &host : hosts) { + host.host->cleanUp(); + host.host->finalizeHostModule("TCP"); + } + + netSystem.run(TimeUtil::makeTime(2000, TimeUtil::SEC)); + } + void checkTest(bool skip_server = false) { + for (auto &connection : connections) { + uint8_t server_id = std::get<0>(connection); + uint8_t client_id = std::get<1>(connection); + std::string client_command = std::get<2>(connection); + size_t app_id = std::get<3>(connection); + std::string server_hello = servers[server_id]; + + std::string server_ip = "10.0.0." + std::to_string(server_id + 1); + std::string client_ip = + "10.0.0." + std::to_string(servers.size() + client_id + 1); + auto &server = hosts[server_id]; + auto &client = hosts[servers.size() + client_id]; + std::string server_ans = server.apps[0].answers[client_ip]; + std::string expected_server_ans = client_command; + if (!skip_server) + EXPECT_EQ(server_ans, expected_server_ans); + + auto &client_app = client.apps[app_id]; + std::string client_ans = client_app.answers[server_ip]; + std::string expected_client_ans; + if (client_command == "hello") { + expected_client_ans = server_hello; + } else if (client_command == "whoami") { + expected_client_ans = client_ip; + } else if (client_command == "whoru") { + expected_client_ans = server_ip; + } else { + expected_client_ans = client_command; + } + EXPECT_EQ(client_ans, expected_client_ans); + } + } +}; + +TEST_F(EchoTesting, SingleEcho) { + SetUp({"server-hello"}, 1, {{0, 0, "echo-test"}}); + runTest(); + checkTest(); +} +TEST_F(EchoTesting, SingleWhoRU) { + SetUp({"server-hello1"}, 1, {{0, 0, "whoru"}}); + runTest(); + checkTest(); +} +TEST_F(EchoTesting, SingleWhoAmI) { + SetUp({"server-hello2"}, 1, {{0, 0, "whoami"}}); + runTest(); + checkTest(); +} +TEST_F(EchoTesting, SingleHello) { + SetUp({"server-hello3"}, 1, {{0, 0, "hello"}}); + runTest(); + checkTest(); +} +TEST_F(EchoTesting, OnetoManyEcho) { + SetUp({"server-hello4"}, 33, + { + {0, 0, "echo-hello0"}, {0, 1, "echo-hello1"}, + {0, 2, "echo-hello2"}, {0, 3, "echo-hello3"}, + {0, 4, "echo-hello4"}, {0, 5, "echo-hello5"}, + {0, 6, "echo-hello6"}, {0, 7, "echo-hello7"}, + {0, 8, "echo-hello8"}, {0, 9, "echo-hello9"}, + {0, 10, "echo-hello10"}, {0, 11, "echo-hello11"}, + {0, 12, "echo-hello12"}, {0, 13, "echo-hello13"}, + {0, 14, "echo-hello14"}, {0, 15, "echo-hello15"}, + {0, 16, "echo-hello16"}, {0, 17, "echo-hello17"}, + {0, 18, "echo-hello18"}, {0, 19, "echo-hello19"}, + {0, 20, "echo-hello20"}, {0, 21, "echo-hello21"}, + {0, 22, "echo-hello22"}, {0, 23, "echo-hello23"}, + {0, 24, "echo-hello24"}, {0, 25, "echo-hello25"}, + {0, 26, "echo-hello26"}, {0, 27, "echo-hello27"}, + {0, 28, "echo-hello28"}, {0, 29, "echo-hello29"}, + {0, 30, "echo-hello30"}, {0, 31, "echo-hello31"}, + {0, 32, "echo-hello32"}, + }); + runTest(); + checkTest(); +} +TEST_F(EchoTesting, OnetoManyWhoRU) { + SetUp({"server-hello5"}, 33, + { + {0, 0, "whoru"}, {0, 1, "whoru"}, {0, 2, "whoru"}, + {0, 3, "whoru"}, {0, 4, "whoru"}, {0, 5, "whoru"}, + {0, 6, "whoru"}, {0, 7, "whoru"}, {0, 8, "whoru"}, + {0, 9, "whoru"}, {0, 10, "whoru"}, {0, 11, "whoru"}, + {0, 12, "whoru"}, {0, 13, "whoru"}, {0, 14, "whoru"}, + {0, 15, "whoru"}, {0, 16, "whoru"}, {0, 17, "whoru"}, + {0, 18, "whoru"}, {0, 19, "whoru"}, {0, 20, "whoru"}, + {0, 21, "whoru"}, {0, 22, "whoru"}, {0, 23, "whoru"}, + {0, 24, "whoru"}, {0, 25, "whoru"}, {0, 26, "whoru"}, + {0, 27, "whoru"}, {0, 28, "whoru"}, {0, 29, "whoru"}, + {0, 30, "whoru"}, {0, 31, "whoru"}, {0, 32, "whoru"}, + }); + runTest(); + checkTest(); +} + +TEST_F(EchoTesting, OnetoManyWhoAmI) { + SetUp({"server-hello6"}, 33, + { + {0, 0, "whoami"}, {0, 1, "whoami"}, {0, 2, "whoami"}, + {0, 3, "whoami"}, {0, 4, "whoami"}, {0, 5, "whoami"}, + {0, 6, "whoami"}, {0, 7, "whoami"}, {0, 8, "whoami"}, + {0, 9, "whoami"}, {0, 10, "whoami"}, {0, 11, "whoami"}, + {0, 12, "whoami"}, {0, 13, "whoami"}, {0, 14, "whoami"}, + {0, 15, "whoami"}, {0, 16, "whoami"}, {0, 17, "whoami"}, + {0, 18, "whoami"}, {0, 19, "whoami"}, {0, 20, "whoami"}, + {0, 21, "whoami"}, {0, 22, "whoami"}, {0, 23, "whoami"}, + {0, 24, "whoami"}, {0, 25, "whoami"}, {0, 26, "whoami"}, + {0, 27, "whoami"}, {0, 28, "whoami"}, {0, 29, "whoami"}, + {0, 30, "whoami"}, {0, 31, "whoami"}, {0, 32, "whoami"}, + }); + runTest(); + checkTest(); +} + +TEST_F(EchoTesting, OnetoManyHello) { + SetUp({"server-hello7"}, 33, + { + {0, 0, "hello"}, {0, 1, "hello"}, {0, 2, "hello"}, + {0, 3, "hello"}, {0, 4, "hello"}, {0, 5, "hello"}, + {0, 6, "hello"}, {0, 7, "hello"}, {0, 8, "hello"}, + {0, 9, "hello"}, {0, 10, "hello"}, {0, 11, "hello"}, + {0, 12, "hello"}, {0, 13, "hello"}, {0, 14, "hello"}, + {0, 15, "hello"}, {0, 16, "hello"}, {0, 17, "hello"}, + {0, 18, "hello"}, {0, 19, "hello"}, {0, 20, "hello"}, + {0, 21, "hello"}, {0, 22, "hello"}, {0, 23, "hello"}, + {0, 24, "hello"}, {0, 25, "hello"}, {0, 26, "hello"}, + {0, 27, "hello"}, {0, 28, "hello"}, {0, 29, "hello"}, + {0, 30, "hello"}, {0, 31, "hello"}, {0, 32, "hello"}, + }); + runTest(); + checkTest(); +} + +TEST_F(EchoTesting, OnetoManyAll) { + SetUp({"server-hello8"}, 33, + { + {0, 0, "echo-hello0"}, {0, 1, "echo-hello1"}, + {0, 2, "echo-hello2"}, {0, 3, "echo-hello3"}, + {0, 4, "echo-hello4"}, {0, 5, "echo-hello5"}, + {0, 6, "echo-hello6"}, {0, 7, "echo-hello7"}, + {0, 8, "echo-hello8"}, {0, 9, "echo-hello9"}, + {0, 10, "echo-hello10"}, {0, 11, "echo-hello11"}, + {0, 12, "echo-hello12"}, {0, 13, "echo-hello13"}, + {0, 14, "echo-hello14"}, {0, 15, "echo-hello15"}, + {0, 16, "echo-hello16"}, {0, 17, "echo-hello17"}, + {0, 18, "echo-hello18"}, {0, 19, "echo-hello19"}, + {0, 20, "echo-hello20"}, {0, 21, "echo-hello21"}, + {0, 22, "echo-hello22"}, {0, 23, "echo-hello23"}, + {0, 24, "echo-hello24"}, {0, 25, "echo-hello25"}, + {0, 26, "echo-hello26"}, {0, 27, "echo-hello27"}, + {0, 28, "echo-hello28"}, {0, 29, "echo-hello29"}, + {0, 30, "echo-hello30"}, {0, 31, "echo-hello31"}, + {0, 32, "echo-hello32"}, {0, 0, "whoru"}, + {0, 1, "whoru"}, {0, 2, "whoru"}, + {0, 3, "whoru"}, {0, 4, "whoru"}, + {0, 5, "whoru"}, {0, 6, "whoru"}, + {0, 7, "whoru"}, {0, 8, "whoru"}, + {0, 9, "whoru"}, {0, 10, "whoru"}, + {0, 11, "whoru"}, {0, 12, "whoru"}, + {0, 13, "whoru"}, {0, 14, "whoru"}, + {0, 15, "whoru"}, {0, 16, "whoru"}, + {0, 17, "whoru"}, {0, 18, "whoru"}, + {0, 19, "whoru"}, {0, 20, "whoru"}, + {0, 21, "whoru"}, {0, 22, "whoru"}, + {0, 23, "whoru"}, {0, 24, "whoru"}, + {0, 25, "whoru"}, {0, 26, "whoru"}, + {0, 27, "whoru"}, {0, 28, "whoru"}, + {0, 29, "whoru"}, {0, 30, "whoru"}, + {0, 31, "whoru"}, {0, 32, "whoru"}, + {0, 0, "whoami"}, {0, 1, "whoami"}, + {0, 2, "whoami"}, {0, 3, "whoami"}, + {0, 4, "whoami"}, {0, 5, "whoami"}, + {0, 6, "whoami"}, {0, 7, "whoami"}, + {0, 8, "whoami"}, {0, 9, "whoami"}, + {0, 10, "whoami"}, {0, 11, "whoami"}, + {0, 12, "whoami"}, {0, 13, "whoami"}, + {0, 14, "whoami"}, {0, 15, "whoami"}, + {0, 16, "whoami"}, {0, 17, "whoami"}, + {0, 18, "whoami"}, {0, 19, "whoami"}, + {0, 20, "whoami"}, {0, 21, "whoami"}, + {0, 22, "whoami"}, {0, 23, "whoami"}, + {0, 24, "whoami"}, {0, 25, "whoami"}, + {0, 26, "whoami"}, {0, 27, "whoami"}, + {0, 28, "whoami"}, {0, 29, "whoami"}, + {0, 30, "whoami"}, {0, 31, "whoami"}, + {0, 32, "whoami"}, {0, 0, "hello"}, + {0, 1, "hello"}, {0, 2, "hello"}, + {0, 3, "hello"}, {0, 4, "hello"}, + {0, 5, "hello"}, {0, 6, "hello"}, + {0, 7, "hello"}, {0, 8, "hello"}, + {0, 9, "hello"}, {0, 10, "hello"}, + {0, 11, "hello"}, {0, 12, "hello"}, + {0, 13, "hello"}, {0, 14, "hello"}, + {0, 15, "hello"}, {0, 16, "hello"}, + {0, 17, "hello"}, {0, 18, "hello"}, + {0, 19, "hello"}, {0, 20, "hello"}, + {0, 21, "hello"}, {0, 22, "hello"}, + {0, 23, "hello"}, {0, 24, "hello"}, + {0, 25, "hello"}, {0, 26, "hello"}, + {0, 27, "hello"}, {0, 28, "hello"}, + {0, 29, "hello"}, {0, 30, "hello"}, + {0, 31, "hello"}, {0, 32, "hello"}, + }); + runTest(); + checkTest(true); +} + +TEST_F(EchoTesting, ManytoOneEcho) { + SetUp( + { + "server0", + "server1", + "server2", + "server3", + "server4", + "server5", + "server6", + "server7", + "server8", + "server9", + }, + 1, + { + {0, 0, "echo-hello0"}, + {1, 0, "echo-hello1"}, + {2, 0, "echo-hello2"}, + {3, 0, "echo-hello3"}, + {4, 0, "echo-hello4"}, + {5, 0, "echo-hello5"}, + {6, 0, "echo-hello6"}, + {7, 0, "echo-hello7"}, + {8, 0, "echo-hello8"}, + {9, 0, "echo-hello9"}, + }); + runTest(); + checkTest(); +} + +TEST_F(EchoTesting, ManytoOneWhoRU) { + SetUp( + { + "server0", + "server1", + "server2", + "server3", + "server4", + "server5", + "server6", + "server7", + "server8", + "server9", + }, + 1, + { + {0, 0, "whoru"}, + {1, 0, "whoru"}, + {2, 0, "whoru"}, + {3, 0, "whoru"}, + {4, 0, "whoru"}, + {5, 0, "whoru"}, + {6, 0, "whoru"}, + {7, 0, "whoru"}, + {8, 0, "whoru"}, + {9, 0, "whoru"}, + }); + runTest(); + checkTest(); +} +TEST_F(EchoTesting, ManytoOneWhoAmI) { + SetUp( + { + "server0", + "server1", + "server2", + "server3", + "server4", + "server5", + "server6", + "server7", + "server8", + "server9", + }, + 1, + { + {0, 0, "whoami"}, + {1, 0, "whoami"}, + {2, 0, "whoami"}, + {3, 0, "whoami"}, + {4, 0, "whoami"}, + {5, 0, "whoami"}, + {6, 0, "whoami"}, + {7, 0, "whoami"}, + {8, 0, "whoami"}, + {9, 0, "whoami"}, + }); + runTest(); + checkTest(); +} +TEST_F(EchoTesting, ManytoOneHello) { + SetUp( + { + "server0", + "server1", + "server2", + "server3", + "server4", + "server5", + "server6", + "server7", + "server8", + "server9", + }, + 1, + { + {0, 0, "hello"}, + {1, 0, "hello"}, + {2, 0, "hello"}, + {3, 0, "hello"}, + {4, 0, "hello"}, + {5, 0, "hello"}, + {6, 0, "hello"}, + {7, 0, "hello"}, + {8, 0, "hello"}, + {9, 0, "hello"}, + }); + runTest(); + checkTest(); +} +TEST_F(EchoTesting, ManytoOneAll) { + SetUp( + { + "server0", + "server1", + "server2", + "server3", + "server4", + "server5", + "server6", + "server7", + "server8", + "server9", + }, + 1, + { + {0, 0, "echo-hello0"}, {1, 0, "echo-hello1"}, {2, 0, "echo-hello2"}, + {3, 0, "echo-hello3"}, {4, 0, "echo-hello4"}, {5, 0, "echo-hello5"}, + {6, 0, "echo-hello6"}, {7, 0, "echo-hello7"}, {8, 0, "echo-hello8"}, + {9, 0, "echo-hello9"}, {0, 0, "whoru"}, {1, 0, "whoru"}, + {2, 0, "whoru"}, {3, 0, "whoru"}, {4, 0, "whoru"}, + {5, 0, "whoru"}, {6, 0, "whoru"}, {7, 0, "whoru"}, + {8, 0, "whoru"}, {9, 0, "whoru"}, {0, 0, "whoami"}, + {1, 0, "whoami"}, {2, 0, "whoami"}, {3, 0, "whoami"}, + {4, 0, "whoami"}, {5, 0, "whoami"}, {6, 0, "whoami"}, + {7, 0, "whoami"}, {8, 0, "whoami"}, {9, 0, "whoami"}, + {0, 0, "hello"}, {1, 0, "hello"}, {2, 0, "hello"}, + {3, 0, "hello"}, {4, 0, "hello"}, {5, 0, "hello"}, + {6, 0, "hello"}, {7, 0, "hello"}, {8, 0, "hello"}, + {9, 0, "hello"}, + }); + runTest(); + checkTest(true); +} +TEST_F(EchoTesting, ManytoMany) { + SetUp( + { + "server0", + "server1", + "server2", + "server3", + "server4", + "server5", + "server6", + "server7", + "server8", + "server9", + }, + 33, + { + {7, 32, "whoru"}, {9, 16, "whoru"}, + {6, 26, "echo-hello3"}, {5, 13, "whoami"}, + {0, 30, "echo-hello5"}, {6, 31, "echo-hello6"}, + {5, 1, "whoru"}, {4, 20, "echo-hello8"}, + {3, 30, "whoru"}, {1, 4, "whoami"}, + {2, 1, "whoru"}, {0, 13, "echo-hello12"}, + {8, 30, "whoami"}, {2, 2, "echo-hello14"}, + {3, 18, "whoru"}, {2, 20, "hello"}, + {9, 15, "hello"}, {5, 32, "whoru"}, + {6, 14, "hello"}, {8, 6, "hello"}, + {8, 4, "whoami"}, {7, 24, "hello"}, + {7, 7, "hello"}, {6, 28, "whoru"}, + {2, 5, "hello"}, {8, 31, "echo-hello26"}, + {2, 7, "whoru"}, {4, 28, "hello"}, + {7, 7, "whoami"}, {1, 1, "echo-hello30"}, + {9, 10, "hello"}, {7, 2, "whoami"}, + {4, 23, "whoru"}, {6, 29, "whoami"}, + {2, 1, "hello"}, {3, 29, "whoru"}, + {8, 32, "echo-hello37"}, {7, 5, "whoru"}, + {7, 11, "hello"}, {2, 24, "hello"}, + {1, 13, "echo-hello41"}, {6, 2, "whoru"}, + {1, 24, "whoami"}, {1, 11, "whoami"}, + {2, 24, "whoru"}, {7, 32, "echo-hello46"}, + {2, 8, "hello"}, {0, 15, "hello"}, + {9, 30, "hello"}, {8, 9, "whoami"}, + {0, 6, "whoru"}, {3, 25, "whoru"}, + {3, 29, "whoami"}, {1, 17, "hello"}, + {5, 4, "whoru"}, {3, 25, "whoru"}, + {9, 1, "whoami"}, {6, 17, "whoru"}, + {7, 25, "echo-hello59"}, {7, 0, "hello"}, + {6, 13, "whoru"}, {5, 19, "whoami"}, + {2, 12, "whoami"}, {2, 9, "hello"}, + {2, 17, "hello"}, {6, 26, "whoru"}, + {0, 21, "whoami"}, {9, 28, "hello"}, + {6, 20, "whoru"}, {6, 2, "echo-hello70"}, + {0, 23, "whoru"}, {2, 10, "whoru"}, + {4, 5, "echo-hello73"}, {2, 2, "whoru"}, + {9, 31, "whoru"}, {4, 32, "whoru"}, + {3, 26, "hello"}, {4, 21, "whoami"}, + {0, 4, "echo-hello79"}, {2, 10, "whoru"}, + {1, 29, "whoami"}, {4, 11, "whoami"}, + {4, 32, "whoru"}, {0, 26, "hello"}, + {6, 2, "whoru"}, {6, 14, "whoami"}, + {3, 3, "whoru"}, {3, 29, "echo-hello88"}, + {3, 32, "whoru"}, {0, 21, "whoru"}, + {8, 27, "echo-hello91"}, {7, 13, "whoami"}, + {5, 17, "echo-hello93"}, {4, 22, "hello"}, + {6, 14, "echo-hello95"}, {8, 14, "whoami"}, + {7, 24, "hello"}, {1, 9, "whoru"}, + {5, 4, "hello"}, {1, 23, "hello"}, + {1, 16, "hello"}, {1, 8, "whoru"}, + {6, 28, "hello"}, {7, 0, "echo-hello104"}, + {9, 30, "whoru"}, {4, 8, "echo-hello106"}, + {7, 11, "echo-hello107"}, {6, 24, "echo-hello108"}, + {3, 6, "echo-hello109"}, {4, 31, "whoami"}, + {8, 21, "hello"}, {0, 8, "echo-hello112"}, + {8, 6, "hello"}, {6, 1, "whoru"}, + {9, 21, "hello"}, {5, 18, "hello"}, + {5, 19, "whoru"}, {2, 15, "whoami"}, + {5, 17, "whoami"}, {9, 20, "hello"}, + {9, 28, "whoru"}, {6, 28, "whoami"}, + {5, 13, "whoru"}, {5, 23, "whoami"}, + {7, 11, "echo-hello125"}, {4, 21, "whoami"}, + {1, 19, "hello"}, {0, 9, "whoami"}, + {8, 32, "echo-hello129"}, {3, 14, "echo-hello130"}, + {5, 0, "whoru"}, {7, 7, "echo-hello132"}, + {9, 27, "whoami"}, {0, 24, "echo-hello134"}, + {3, 22, "hello"}, {5, 29, "whoami"}, + {2, 5, "whoami"}, {1, 25, "hello"}, + {5, 32, "hello"}, {5, 18, "whoru"}, + {8, 27, "hello"}, {4, 24, "hello"}, + {0, 9, "whoami"}, {1, 11, "hello"}, + {4, 15, "hello"}, {8, 16, "hello"}, + {9, 15, "whoami"}, {6, 25, "echo-hello148"}, + {4, 25, "whoru"}, {2, 4, "whoami"}, + {4, 13, "hello"}, {7, 17, "hello"}, + {9, 31, "whoami"}, {2, 26, "hello"}, + {7, 32, "whoami"}, {7, 32, "whoru"}, + {1, 27, "whoami"}, {2, 12, "whoami"}, + {1, 4, "hello"}, {0, 8, "whoru"}, + {4, 15, "whoami"}, {4, 19, "hello"}, + {1, 12, "whoru"}, {2, 23, "whoami"}, + {4, 22, "hello"}, {5, 22, "whoru"}, + {4, 29, "whoami"}, {9, 18, "echo-hello168"}, + {8, 21, "echo-hello169"}, {8, 5, "whoru"}, + {8, 17, "hello"}, {6, 8, "whoami"}, + {8, 20, "echo-hello173"}, {0, 5, "hello"}, + {1, 5, "whoru"}, {6, 7, "whoami"}, + {2, 26, "echo-hello177"}, {9, 28, "whoami"}, + {6, 3, "echo-hello179"}, {0, 26, "whoami"}, + {4, 6, "echo-hello181"}, {9, 20, "hello"}, + {7, 16, "whoru"}, {4, 19, "hello"}, + {9, 7, "echo-hello185"}, {2, 14, "hello"}, + {0, 8, "whoru"}, {9, 28, "echo-hello188"}, + {4, 11, "echo-hello189"}, {3, 32, "echo-hello190"}, + {4, 24, "hello"}, {3, 1, "whoru"}, + {4, 23, "whoami"}, {4, 3, "echo-hello194"}, + {0, 2, "hello"}, {4, 3, "echo-hello196"}, + {2, 17, "hello"}, {0, 8, "echo-hello198"}, + {1, 21, "echo-hello199"}, {9, 7, "echo-hello200"}, + {5, 12, "whoru"}, {6, 15, "whoami"}, + {3, 18, "echo-hello203"}, {8, 29, "whoru"}, + {3, 25, "whoru"}, {3, 25, "whoami"}, + {2, 3, "whoami"}, {2, 11, "whoru"}, + {8, 13, "hello"}, {9, 21, "whoru"}, + {2, 4, "whoru"}, {1, 23, "hello"}, + {6, 29, "hello"}, {4, 11, "whoami"}, + {1, 5, "hello"}, {5, 6, "whoami"}, + }); + runTest(); + checkTest(true); +} \ No newline at end of file