diff --git a/CMakeLists.txt b/CMakeLists.txt index 7b3d679..0a5084b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -83,20 +83,46 @@ if(ENET_TEST) # Default test add_executable(enet_test test/build.c) target_link_libraries(enet_test PRIVATE enet_test_interface) - + # Test with more peers add_executable(enet_test_extra_peers test/build.c) target_link_libraries(enet_test_extra_peers PRIVATE enet_test_interface) target_compile_definitions(enet_test_extra_peers PRIVATE ENET_USE_MORE_PEERS) - # Test unit - add_executable(enet_test_unit test/units/test_main.c) - target_link_libraries(enet_test_unit PRIVATE enet_test_interface) - target_include_directories(enet_test_unit INTERFACE + # enet test units + file(GLOB UNIT_TEST_SOURCES CONFIGURE_DEPENDS "test/units/*.c") + add_library(enet_test_units STATIC ${UNIT_TEST_SOURCES}) + target_include_directories(enet_test_units PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include ${CMAKE_CURRENT_SOURCE_DIR}/test/units/include ) -endif() + + # enet test units run + add_executable(enet_test_unit_run test/unit_tests.c) + target_link_libraries(enet_test_unit_run PRIVATE + enet_test_interface + enet_test_units + ) + + if (MSVC) + target_link_options(enet_test_unit_run PRIVATE + "/WHOLEARCHIVE:enet_test_units" + ) + elseif (APPLE) + target_link_libraries(enet_test_unit_run PRIVATE + "-Wl,-force_load,${CMAKE_BINARY_DIR}/libenet_test_units.a" + ) + else() + target_link_libraries(enet_test_unit_run PRIVATE + "-Wl,--whole-archive" enet_test_units "-Wl,--no-whole-archive" + ) + endif() + + target_include_directories(enet_test_unit_run PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/include + ${CMAKE_CURRENT_SOURCE_DIR}/test/units/include + ) +endif () # ----------------------------- # 5) Installation diff --git a/test/resize.c b/test/resize.c deleted file mode 100644 index 4565503..0000000 --- a/test/resize.c +++ /dev/null @@ -1,16 +0,0 @@ -#define ENET_IMPLEMENTATION -#include "enet.h" -int main() { - ENetPacket *packet = enet_packet_create("packet", - strlen("packet"), - ENET_PACKET_FLAG_RELIABLE); - printf("length: %d, data: %.*s\n", packet->dataLength, packet->dataLength, (char*)packet->data); - packet = enet_packet_resize(packet, strlen("packetfoo")); - strcpy (& packet -> data [strlen ("packet")], "foo"); - printf("length: %d, data: %.*s\n", packet->dataLength, packet->dataLength, (char*)packet->data); - packet = enet_packet_resize(packet, strlen("packet")); - printf("length: %d, data: %.*s\n", packet->dataLength, packet->dataLength, (char*)packet->data); - packet = enet_packet_resize(packet, strlen("packetfoobar")); - strcpy (& packet -> data [strlen ("packet")], "foobar"); - printf("length: %d, data: %.*s\n", packet->dataLength, packet->dataLength, (char*)packet->data); -} diff --git a/test/units/test_main.c b/test/unit_tests.c similarity index 73% rename from test/units/test_main.c rename to test/unit_tests.c index 3220ca2..25e4fd4 100644 --- a/test/units/test_main.c +++ b/test/unit_tests.c @@ -1,8 +1,10 @@ #include +#define ENET_UNIT_IMPLEMENTATION +#define ENET_IMPLEMENTATION + #include "enet.h" -#include "enet_unit.h" -#include "test_times.c" +#include "units/enet_unit.h" int main() { if (enet_initialize() != 0) { diff --git a/test/units/enet_unit.h b/test/units/enet_unit.h index afaec19..0401e71 100644 --- a/test/units/enet_unit.h +++ b/test/units/enet_unit.h @@ -9,6 +9,49 @@ #include #endif +#ifdef _WIN32 +#define TEST_SLEEP(ms) Sleep(ms) +#else +#define TEST_SLEEP(ms) usleep(ms * 1000); +#endif + + +#define ENET_EXPAND(x) x +#define GET_MACRO(_1, _2, _3, NAME, ...) NAME + +#define OP_EQ(a, b) ((a) == (b)) +#define OP_NE(a, b) ((a) != (b)) +#define OP_CALL(op, a, b) (op(a, b)) + +#define ASSERT_EQ(...) ENET_EXPAND( GET_MACRO(__VA_ARGS__, ASSERT_THAT_IMPL3, ASSERT_THAT_IMPL2)(ASSERT_EQ, OP_EQ, __VA_ARGS__) ) +#define ASSERT_NE(...) ENET_EXPAND( GET_MACRO(__VA_ARGS__, ASSERT_THAT_IMPL3, ASSERT_THAT_IMPL2)(ASSERT_NE, OP_NE, __VA_ARGS__) ) + +#define ASSERT_THAT_IMPL2(cmd, op, a, b) \ +do { \ + if (!OP_CALL(op, a, b)) { \ + entry->failed += 1; \ + fprintf(stderr, "%s(%s, %s)\n", #cmd, #a, #b); \ + fprintf(stderr, " Expected: %s\n", #b); \ + fprintf(stderr, " But was: %s\n", #a); \ + fprintf(stderr, "at %s:%d\n", __FILE__, __LINE__); \ + return; \ + } \ +} while (0) + + +#define ASSERT_THAT_IMPL3(cmd, op, a, b, m) \ +do { \ + if (!OP_CALL(op, a, b)) { \ + entry->failed += 1; \ + fprintf(stderr, "%s\n", m); \ + fprintf(stderr, "%s(%s, %s)\n", #cmd, #a, #b); \ + fprintf(stderr, " Expected: %s\n", #b); \ + fprintf(stderr, " But was: %s\n", #a); \ + fprintf(stderr, "at %s:%d\n", __FILE__, __LINE__); \ + return; \ + } \ +} while (0) + typedef struct _ENetTestEntry ENetTestEntry; typedef void (*ENetUnitTestFunc)(ENetTestEntry *entry); @@ -21,18 +64,15 @@ typedef struct _ENetTestEntry { #define MAX_TESTS 8096 -static ENetTestEntry enet_test_entries[MAX_TESTS]; -static int enet_test_count = 0; - -#ifdef _WIN32 -#define ASSERT_SLEEP(ms) Sleep(ms) +#ifdef ENET_UNIT_IMPLEMENTATION +ENetTestEntry enet_test_entries[MAX_TESTS]; +int enet_test_count = 0; #else -#define ASSERT_SLEEP(ms) usleep(ms * 1000); +extern ENetTestEntry enet_test_entries[MAX_TESTS]; +extern int enet_test_count; #endif -#define ENET_EXPAND(x) x -#define GET_MACRO(_1, _2, _3, NAME, ...) NAME -#define ASSERT_THAT(...) ENET_EXPAND( GET_MACRO(__VA_ARGS__, ASSERT_THAT_IMPL3, ASSERT_THAT_IMPL2)(__VA_ARGS__) ) +int run_all_tests(void); #define ENET_TEST_REGISTER(f) \ do { \ @@ -65,33 +105,11 @@ static void __cdecl func(void) } \ static void enet_test_##func(ENetTestEntry * entry) -#define ASSERT_THAT_IMPL3(a, b, m) do { \ - if ((a) != (b)) { \ - entry->failed += 1; \ - fprintf(stderr, "%s\n", m); \ - fprintf(stderr, "ASSERT_THAT(%s, %s)\n", #a, #b); \ - fprintf(stderr, " Expected: %s\n", #b); \ - fprintf(stderr, " But was: %s\n", #a); \ - fprintf(stderr, "at %s:%d\n", __FILE__, __LINE__); \ - return; \ - } \ -} while (0) - -#define ASSERT_THAT_IMPL2(a, b) do { \ - if ((a) != (b)) { \ - entry->failed += 1; \ - fprintf(stderr, "ASSERT_THAT(%s, %s)\n", #a, #b); \ - fprintf(stderr, " Expected: %s\n", #b); \ - fprintf(stderr, " But was: %s\n", #a); \ - fprintf(stderr, "at %s:%d\n", __FILE__, __LINE__); \ - return; \ - } \ -} while (0) - -static int run_all_tests(void) { +#ifdef ENET_UNIT_IMPLEMENTATION +extern int run_all_tests(void) { int failed = 0; for (int i = 0; i < enet_test_count; ++i) { - const char* prefix = "enet_test_"; + const char *prefix = "enet_test_"; ENetTestEntry *entry = &enet_test_entries[i]; const char *funcName = entry->name + strlen(prefix); @@ -115,5 +133,6 @@ static int run_all_tests(void) { return failed; } +#endif #endif diff --git a/test/units/test_lists.c b/test/units/test_lists.c new file mode 100644 index 0000000..6865097 --- /dev/null +++ b/test/units/test_lists.c @@ -0,0 +1,326 @@ +#include "enet.h" +#include "enet_unit.h" + +// Test structure to use in our list +typedef struct TestNode { + ENetListNode node; + int value; +} TestNode; + +TEST(enet_list_insert) { + ENetList list; + TestNode node0 = {0}; + TestNode node1 = {0}; + TestNode node2 = {0}; + node0.value = 0; + node1.value = 1; + node2.value = 2; + + // for begin + { + enet_list_clear(&list); + enet_list_insert(enet_list_begin(&list), &node0); + enet_list_insert(enet_list_begin(&list), &node1); + enet_list_insert(enet_list_begin(&list), &node2); + + ENetListIterator b0 = enet_list_begin(&list); + ENetListIterator b1 = enet_list_next(b0); + ENetListIterator b2 = enet_list_next(b1); + + ASSERT_EQ(((TestNode *)b0)->value, 2); + ASSERT_EQ(((TestNode *)b1)->value, 1); + ASSERT_EQ(((TestNode *)b2)->value, 0); + } + + // for end + { + enet_list_clear(&list); + enet_list_insert(enet_list_end(&list), &node0); + enet_list_insert(enet_list_end(&list), &node1); + enet_list_insert(enet_list_end(&list), &node2); + + ENetListIterator b0 = enet_list_begin(&list); + ENetListIterator b1 = enet_list_next(b0); + ENetListIterator b2 = enet_list_next(b1); + + ASSERT_EQ(((TestNode *)b0)->value, 0); + ASSERT_EQ(((TestNode *)b1)->value, 1); + ASSERT_EQ(((TestNode *)b2)->value, 2); + } + + // for position + { + enet_list_clear(&list); + enet_list_insert(enet_list_end(&list), &node0); + enet_list_insert(enet_list_end(&list), &node1); + + ENetListIterator middle = enet_list_next(enet_list_begin(&list)); + enet_list_insert(middle, &node2); + + ENetListIterator b0 = enet_list_begin(&list); + ENetListIterator b1 = enet_list_next(b0); + ENetListIterator b2 = enet_list_next(b1); + + ASSERT_EQ(((TestNode *)b0)->value, 0); + ASSERT_EQ(((TestNode *)b1)->value, 2); + ASSERT_EQ(((TestNode *)b2)->value, 1); + } + + // // Test inserting the same node multiple times + // { + // enet_list_clear(&list); + // + // // First insert + // enet_list_insert(enet_list_end(&list), &node0); + // ASSERT_EQ(enet_list_size(&list), 1); + // + // // Try to insert the same node again + // enet_list_insert(enet_list_end(&list), &node0); + // ASSERT_EQ(enet_list_size(&list), 1); // Size should not change + // + // // Verify list integrity + // ENetListIterator current = enet_list_begin(&list); + // ENetListIterator next = enet_list_next(current); + // ASSERT_EQ(next, enet_list_end(&list)); // Should be the only node + // } + + // // Test inserting the same node in different lists + // { + // ENetList list1, list2; + // enet_list_clear(&list1); + // enet_list_clear(&list2); + // + // // Insert into first list + // enet_list_insert(enet_list_end(&list1), &node0); + // ASSERT_EQ(enet_list_size(&list1), 1); + // ASSERT_EQ(enet_list_size(&list2), 0); + // + // // Try to insert into second list + // enet_list_insert(enet_list_end(&list2), &node0); + // ASSERT_EQ(enet_list_size(&list1), 0); // Should be removed from first list + // ASSERT_EQ(enet_list_size(&list2), 1); // Should be in second list + // } +} + +TEST(enet_list_remove) { + ENetList list; + TestNode node0 = {0}; + TestNode node1 = {0}; + TestNode node2 = {0}; + node0.value = 0; + node1.value = 1; + node2.value = 2; + + // Test 1: Remove already removed node (edge case) + { + enet_list_clear(&list); + enet_list_insert(enet_list_end(&list), &node0); + + ENetListIterator first = enet_list_begin(&list); + enet_list_remove(first); + enet_list_remove(first); // Should not crash when removing already removed node + ASSERT_EQ(enet_list_size(&list), 0); + } + + // Test 2: Remove from beginning + { + enet_list_clear(&list); + enet_list_insert(enet_list_end(&list), &node0); + enet_list_insert(enet_list_end(&list), &node1); + enet_list_insert(enet_list_end(&list), &node2); + + enet_list_remove(enet_list_begin(&list)); + ASSERT_EQ(enet_list_size(&list), 2); + + ENetListIterator b0 = enet_list_begin(&list); + ENetListIterator b1 = enet_list_next(b0); + ASSERT_EQ(((TestNode *)b0)->value, 1); + ASSERT_EQ(((TestNode *)b1)->value, 2); + } + + // Test 3: Remove from middle + { + enet_list_clear(&list); + enet_list_insert(enet_list_end(&list), &node0); + enet_list_insert(enet_list_end(&list), &node1); + enet_list_insert(enet_list_end(&list), &node2); + + ENetListIterator middle = enet_list_next(enet_list_begin(&list)); + enet_list_remove(middle); + ASSERT_EQ(enet_list_size(&list), 2); + + ENetListIterator b0 = enet_list_begin(&list); + ENetListIterator b1 = enet_list_next(b0); + ASSERT_EQ(((TestNode *)b0)->value, 0); + ASSERT_EQ(((TestNode *)b1)->value, 2); + } + + // Test 4: Remove from end + { + enet_list_clear(&list); + enet_list_insert(enet_list_end(&list), &node0); + enet_list_insert(enet_list_end(&list), &node1); + enet_list_insert(enet_list_end(&list), &node2); + + ENetListIterator last = enet_list_previous(enet_list_end(&list)); + enet_list_remove(last); + ASSERT_EQ(enet_list_size(&list), 2); + + ENetListIterator b0 = enet_list_begin(&list); + ENetListIterator b1 = enet_list_next(b0); + ASSERT_EQ(((TestNode *)b0)->value, 0); + ASSERT_EQ(((TestNode *)b1)->value, 1); + } +} + + +TEST(enet_list_move) { + ENetList list1, list2; + TestNode nodes[10] = {0}; // Increased to 10 nodes for more comprehensive testing + + for (int i = 0; i < 10; i++) { + nodes[i].value = i; + } + + // Initialize lists + enet_list_clear(&list1); + enet_list_clear(&list2); + + // Insert 5 nodes into first list with values 0-4 + for (int i = 0; i < 5; i++) { + enet_list_insert(enet_list_end(&list1), &nodes[i].node); + } + + // Insert 5 nodes into second list with values 5-9 + for (int i = 5; i < 10; i++) { + enet_list_insert(enet_list_end(&list2), &nodes[i].node); + } + ASSERT_EQ(enet_list_size(&list1), 5); + ASSERT_EQ(enet_list_size(&list2), 5); + + // Test 1: Move single node from list2 to list1 + ENetListIterator n6 = enet_list_next(enet_list_begin(&list2)); + ENetListIterator n8 = enet_list_next(enet_list_next(n6)); + enet_list_move(enet_list_end(&list2), n6, n8); + + // Verify node order in list1 + int expected_values1[] = {0, 1, 2, 3, 4, 6, 7, 8}; + int i = 0; + for (ENetListNode *current = enet_list_begin(&list1); + current != enet_list_end(&list1); + current = enet_list_next(current)) { + TestNode *node = (TestNode *) current; + ASSERT_EQ(node->value, expected_values1[i++]); + } + + // // Verify node order in list2 + // int expected_values2[] = {5, 9}; + // i = 0; + // for (ENetListNode *current = enet_list_begin(&list2); + // current != enet_list_end(&list2); + // current = enet_list_next(current)) { + // TestNode *node = (TestNode *) current; + // ASSERT_EQ(node->value, expected_values2[i++]); + // } + + // // Test 2: Move node to beginning of list + // enet_list_move(enet_list_begin(&list1), &nodes[8].node); + // ASSERT_EQ(enet_list_size(&list1), 5); + // ASSERT_EQ(enet_list_size(&list2), 5); + // + // // Test 3: Move node to middle of list + // enet_list_move(enet_list_next(enet_list_begin(&list1)), &nodes[5].node); + // ASSERT_EQ(enet_list_size(&list1), 6); + // ASSERT_EQ(enet_list_size(&list2), 4); + // + // // Test 4: Move multiple nodes at once + // enet_list_move(enet_list_end(&list2), &nodes[0].node, &nodes[3].node); + // ASSERT_EQ(enet_list_size(&list1), 3); + // ASSERT_EQ(enet_list_size(&list2), 7); + // + // // Test 5: Move node to its current position (should not change anything) + // enet_list_move(enet_list_next(enet_list_begin(&list1)), &nodes[8].node); + // ASSERT_EQ(enet_list_size(&list1), 3); + // ASSERT_EQ(enet_list_size(&list2), 7); +} + +TEST(enet_list_clear) { + ENetList list; + TestNode node0 = {0}; + TestNode node1 = {0}; + TestNode node2 = {0}; + node0.value = 0; + node1.value = 1; + node2.value = 2; + + // Initialize list + enet_list_clear(&list); + + // Insert nodes + enet_list_insert(enet_list_end(&list), &node0.node); + enet_list_insert(enet_list_end(&list), &node1.node); + enet_list_insert(enet_list_end(&list), &node2.node); + + ASSERT_EQ(enet_list_size(&list), 3); + + // Clear list + enet_list_clear(&list); + ASSERT_EQ(enet_list_size(&list), 0); +} + +TEST(enet_list_iteration) { + ENetList list; + TestNode nodes[5] = {0}; + int i; + + // Initialize list + enet_list_clear(&list); + + // Insert nodes with values + for (i = 0; i < 5; i++) { + nodes[i].value = i; + enet_list_insert(enet_list_end(&list), &nodes[i].node); + } + + // Iterate through list and verify values + ENetListNode *current; + i = 0; + for (current = enet_list_begin(&list); + current != enet_list_end(&list); + current = enet_list_next(current)) { + TestNode *node = (TestNode *) current; + ASSERT_EQ(node->value, i); + i++; + } + ASSERT_EQ(i, 5); +} + +TEST(enet_list_empty) { + ENetList list; +} + +TEST(enet_list_size) { + ENetList list; + TestNode node0 = {0}; + TestNode node1 = {0}; + TestNode node2 = {0}; + node0.value = 0; + node1.value = 1; + node2.value = 2; + + // Initialize list + enet_list_clear(&list); + ASSERT_EQ(enet_list_size(&list), 0); + + // Insert nodes + enet_list_insert(enet_list_end(&list), &node0.node); + enet_list_insert(enet_list_end(&list), &node1.node); + enet_list_insert(enet_list_end(&list), &node2.node); + ASSERT_EQ(enet_list_size(&list), 3); + + // Remove nodes + enet_list_remove(&node2.node); + enet_list_remove(&node1.node); + enet_list_remove(&node0.node); + ASSERT_EQ(enet_list_size(&list), 0); +} diff --git a/test/units/test_packets.c b/test/units/test_packets.c new file mode 100644 index 0000000..dd98862 --- /dev/null +++ b/test/units/test_packets.c @@ -0,0 +1,58 @@ +#include "enet.h" +#include "enet_unit.h" + +TEST(enet_packet_create_and_destroy) { + ENetPacket *packet = enet_packet_create("foo", strlen("foo"), ENET_PACKET_FLAG_RELIABLE); + + ASSERT_EQ(packet->referenceCount, 0); + ASSERT_EQ(packet->flags, ENET_PACKET_FLAG_RELIABLE); + ASSERT_NE(packet->data, NULL); + ASSERT_EQ(packet->dataLength, 3); + ASSERT_EQ(packet->userData, NULL); + + enet_packet_destroy(packet); +} + +TEST(enet_packet_copy) { + int userData = 1; + ENetPacket *p1 = enet_packet_create("bar", strlen("bar"), ENET_PACKET_FLAG_RELIABLE); + p1->userData = &userData; + + ENetPacket *p2 = enet_packet_copy(p1); + + // + ASSERT_NE(p2, NULL); + ASSERT_NE(p2->data, NULL); + + // + ASSERT_EQ(p2->dataLength, p1->dataLength); + ASSERT_EQ(memcmp(p2->data, p1->data, p1->dataLength), 0); + ASSERT_EQ(p2->flags, p1->flags); + ASSERT_EQ(p2->referenceCount, p1->referenceCount); + ASSERT_EQ(p2->userData, NULL); + + enet_packet_destroy(p1); + enet_packet_destroy(p2); +} + +TEST(enet_packet_resize) { + ENetPacket *packet = enet_packet_create("packet", strlen("packet"), ENET_PACKET_FLAG_RELIABLE); + ASSERT_EQ(memcmp(packet->data, "packet", 6), 0); + ASSERT_EQ(packet->dataLength, 6); + + packet = enet_packet_resize(packet, strlen("packetfoo")); + memcpy(&packet->data[strlen("packet")], "foo", 3); + ASSERT_EQ(memcmp(packet->data, "packetfoo", 9), 0); + ASSERT_EQ(packet->dataLength, 9); + + packet = enet_packet_resize(packet, strlen("packet")); + ASSERT_EQ(memcmp(packet->data, "packet", 6), 0); + ASSERT_EQ(packet->dataLength, 6); + + packet = enet_packet_resize(packet, strlen("packetfoobar")); + memcpy(&packet->data[strlen("packet")], "foobar", 6); + ASSERT_EQ(memcmp(packet->data, "packetfoobar", 12), 0); + ASSERT_EQ(packet->dataLength, 12); + + enet_packet_destroy(packet); +} diff --git a/test/units/test_sockets.c b/test/units/test_sockets.c new file mode 100644 index 0000000..08d8b58 --- /dev/null +++ b/test/units/test_sockets.c @@ -0,0 +1,62 @@ +#include "enet.h" +#include "enet_unit.h" + +TEST(enet_socket_create) { + ENetSocket tcpSock = enet_socket_create(ENET_SOCKET_TYPE_STREAM); + ENetSocket udpSock = enet_socket_create(ENET_SOCKET_TYPE_DATAGRAM); + + ASSERT_NE(tcpSock, ENET_SOCKET_NULL); + ASSERT_NE(udpSock, ENET_SOCKET_NULL); +} + +TEST(enet_socket_bind) { + ASSERT_EQ(0, 1); +} + +TEST(enet_socket_get_address) { + ASSERT_EQ(0, 1); +} + +TEST(enet_socket_listen) { + ASSERT_EQ(0, 1); +} + +TEST(enet_socket_accept) { + ASSERT_EQ(0, 1); +} + +TEST(enet_socket_connect) { + ASSERT_EQ(0, 1); +} + +TEST(enet_socket_send) { + ASSERT_EQ(0, 1); +} + +TEST(enet_socket_receive) { + ASSERT_EQ(0, 1); +} + +TEST(enet_socket_wait) { + ASSERT_EQ(0, 1); +} + +TEST(enet_socket_set_option) { + ASSERT_EQ(0, 1); +} + +TEST(enet_socket_get_option) { + ASSERT_EQ(0, 1); +} + +TEST(enet_socket_shutdown) { + ASSERT_EQ(0, 1); +} + +TEST(enet_socket_destroy) { + ASSERT_EQ(0, 1); +} + +TEST(enet_socketset_select) { + ASSERT_EQ(0, 1); +} diff --git a/test/units/test_times.c b/test/units/test_times.c index 19f5b29..e9fc92f 100644 --- a/test/units/test_times.c +++ b/test/units/test_times.c @@ -5,16 +5,16 @@ TEST(ENET_TIME_LESS) { enet_uint32 a = 1000; enet_uint32 b = 2000; // Normal cases - ASSERT_THAT(ENET_TIME_LESS(a, b), true, "ENET_TIME_LESS should return true for a < b"); - ASSERT_THAT(ENET_TIME_LESS(a, a), false, "ENET_TIME_LESS should return false for a == b"); - ASSERT_THAT(ENET_TIME_LESS(b, a), false, "ENET_TIME_LESS should return false for a > b"); + ASSERT_EQ(ENET_TIME_LESS(a, b), true, "ENET_TIME_LESS should return true for a < b"); + ASSERT_EQ(ENET_TIME_LESS(a, a), false, "ENET_TIME_LESS should return false for a == b"); + ASSERT_EQ(ENET_TIME_LESS(b, a), false, "ENET_TIME_LESS should return false for a > b"); // Cases involving ENET_TIME_OVERFLOW constant - ASSERT_THAT(ENET_TIME_LESS(a, ENET_TIME_OVERFLOW), true, + ASSERT_EQ(ENET_TIME_LESS(a, ENET_TIME_OVERFLOW), true, "ENET_TIME_LESS with a < ENET_TIME_OVERFLOW and b == ENET_TIME_OVERFLOW should be true"); - ASSERT_THAT(ENET_TIME_LESS(ENET_TIME_OVERFLOW, a), false, + ASSERT_EQ(ENET_TIME_LESS(ENET_TIME_OVERFLOW, a), false, "ENET_TIME_LESS with a == ENET_TIME_OVERFLOW and b < ENET_TIME_OVERFLOW should be false"); - ASSERT_THAT(ENET_TIME_LESS(ENET_TIME_OVERFLOW, ENET_TIME_OVERFLOW), false, + ASSERT_EQ(ENET_TIME_LESS(ENET_TIME_OVERFLOW, ENET_TIME_OVERFLOW), false, "ENET_TIME_LESS with a == ENET_TIME_OVERFLOW and b == ENET_TIME_OVERFLOW should be false"); } @@ -22,17 +22,17 @@ TEST(ENET_TIME_GREATER) { enet_uint32 a = 1000; enet_uint32 b = 2000; // Normal cases - ASSERT_THAT(ENET_TIME_GREATER(b, a), true, "ENET_TIME_GREATER should return true for a > b"); - ASSERT_THAT(ENET_TIME_GREATER(a, a), false, "ENET_TIME_GREATER should return false for a == b"); - ASSERT_THAT(ENET_TIME_GREATER(a, b), false, "ENET_TIME_GREATER should return false for a < b"); + ASSERT_EQ(ENET_TIME_GREATER(b, a), true, "ENET_TIME_GREATER should return true for a > b"); + ASSERT_EQ(ENET_TIME_GREATER(a, a), false, "ENET_TIME_GREATER should return false for a == b"); + ASSERT_EQ(ENET_TIME_GREATER(a, b), false, "ENET_TIME_GREATER should return false for a < b"); // Cases involving ENET_TIME_OVERFLOW constant - ASSERT_THAT(ENET_TIME_GREATER(a, ENET_TIME_OVERFLOW), false, + ASSERT_EQ(ENET_TIME_GREATER(a, ENET_TIME_OVERFLOW), false, "ENET_TIME_GREATER with a < ENET_TIME_OVERFLOW and b == ENET_TIME_OVERFLOW should be false"); - ASSERT_THAT(ENET_TIME_GREATER(ENET_TIME_OVERFLOW, a), true, + ASSERT_EQ(ENET_TIME_GREATER(ENET_TIME_OVERFLOW, a), true, "ENET_TIME_GREATER with a == ENET_TIME_OVERFLOW and b < ENET_TIME_OVERFLOW should be true"); // ENET_TIME_GREATER is !ENET_TIME_LESS_EQUAL - ASSERT_THAT(ENET_TIME_GREATER(ENET_TIME_OVERFLOW, ENET_TIME_OVERFLOW), false, + ASSERT_EQ(ENET_TIME_GREATER(ENET_TIME_OVERFLOW, ENET_TIME_OVERFLOW), false, "ENET_TIME_GREATER with a == ENET_TIME_OVERFLOW and b == ENET_TIME_OVERFLOW should be false"); } @@ -40,18 +40,18 @@ TEST(ENET_TIME_LESS_EQUAL) { enet_uint32 a = 1000; enet_uint32 b = 2000; // Normal cases - ASSERT_THAT(ENET_TIME_LESS_EQUAL(a, b), true, "ENET_TIME_LESS_EQUAL should return true for a <= b"); - ASSERT_THAT(ENET_TIME_LESS_EQUAL(a, a), true, + ASSERT_EQ(ENET_TIME_LESS_EQUAL(a, b), true, "ENET_TIME_LESS_EQUAL should return true for a <= b"); + ASSERT_EQ(ENET_TIME_LESS_EQUAL(a, a), true, "ENET_TIME_LESS_EQUAL should return true for a <= b (equal)"); - ASSERT_THAT(ENET_TIME_LESS_EQUAL(b, a), false, + ASSERT_EQ(ENET_TIME_LESS_EQUAL(b, a), false, "ENET_TIME_LESS_EQUAL should return false for a <= b (greater)"); // Cases involving ENET_TIME_OVERFLOW constant - ASSERT_THAT(ENET_TIME_LESS_EQUAL(a, ENET_TIME_OVERFLOW), true, + ASSERT_EQ(ENET_TIME_LESS_EQUAL(a, ENET_TIME_OVERFLOW), true, "ENET_TIME_LESS_EQUAL with a < ENET_TIME_OVERFLOW and b == ENET_TIME_OVERFLOW should be true"); - ASSERT_THAT(ENET_TIME_LESS_EQUAL(ENET_TIME_OVERFLOW, a), false, + ASSERT_EQ(ENET_TIME_LESS_EQUAL(ENET_TIME_OVERFLOW, a), false, "ENET_TIME_LESS_EQUAL with a == ENET_TIME_OVERFLOW and b < ENET_TIME_OVERFLOW should be false"); - ASSERT_THAT(ENET_TIME_LESS_EQUAL(ENET_TIME_OVERFLOW, ENET_TIME_OVERFLOW), true, + ASSERT_EQ(ENET_TIME_LESS_EQUAL(ENET_TIME_OVERFLOW, ENET_TIME_OVERFLOW), true, "ENET_TIME_LESS_EQUAL with a == ENET_TIME_OVERFLOW and b == ENET_TIME_OVERFLOW should be true"); } @@ -59,16 +59,16 @@ TEST(ENET_TIME_GREATER_EQUAL) { enet_uint32 a = 1000; enet_uint32 b = 2000; // Normal cases - ASSERT_THAT(ENET_TIME_GREATER_EQUAL(b, a), true, "ENET_TIME_GREATER_EQUAL should return true for a >= b"); - ASSERT_THAT(ENET_TIME_GREATER_EQUAL(a, a), true, "ENET_TIME_GREATER_EQUAL should return true for a >= b (equal)"); - ASSERT_THAT(ENET_TIME_GREATER_EQUAL(a, b), false, "ENET_TIME_GREATER_EQUAL should return false for a >= b (less)"); + ASSERT_EQ(ENET_TIME_GREATER_EQUAL(b, a), true, "ENET_TIME_GREATER_EQUAL should return true for a >= b"); + ASSERT_EQ(ENET_TIME_GREATER_EQUAL(a, a), true, "ENET_TIME_GREATER_EQUAL should return true for a >= b (equal)"); + ASSERT_EQ(ENET_TIME_GREATER_EQUAL(a, b), false, "ENET_TIME_GREATER_EQUAL should return false for a >= b (less)"); // Cases involving ENET_TIME_OVERFLOW constant (based on ENET_TIME_GREATER logic) - ASSERT_THAT(ENET_TIME_GREATER_EQUAL(a, ENET_TIME_OVERFLOW), false, + ASSERT_EQ(ENET_TIME_GREATER_EQUAL(a, ENET_TIME_OVERFLOW), false, "ENET_TIME_GREATER_EQUAL with a < ENET_TIME_OVERFLOW and b == ENET_TIME_OVERFLOW should be false"); - ASSERT_THAT(ENET_TIME_GREATER_EQUAL(ENET_TIME_OVERFLOW, a), true, + ASSERT_EQ(ENET_TIME_GREATER_EQUAL(ENET_TIME_OVERFLOW, a), true, "ENET_TIME_GREATER_EQUAL with a == ENET_TIME_OVERFLOW and b < ENET_TIME_OVERFLOW should be true"); - ASSERT_THAT(ENET_TIME_GREATER_EQUAL(ENET_TIME_OVERFLOW, ENET_TIME_OVERFLOW), true, + ASSERT_EQ(ENET_TIME_GREATER_EQUAL(ENET_TIME_OVERFLOW, ENET_TIME_OVERFLOW), true, "ENET_TIME_GREATER_EQUAL with a == ENET_TIME_OVERFLOW and b == ENET_TIME_OVERFLOW should be true"); } @@ -76,24 +76,24 @@ TEST(ENET_TIME_DIFFERENCE) { // Normal cases enet_uint32 a = 2000; enet_uint32 b = 1000; - ASSERT_THAT(ENET_TIME_DIFFERENCE(a, b), 1000, + ASSERT_EQ(ENET_TIME_DIFFERENCE(a, b), 1000, "ENET_TIME_DIFFERENCE should return the absolute difference for a > b"); - ASSERT_THAT(ENET_TIME_DIFFERENCE(b, a), 1000, + ASSERT_EQ(ENET_TIME_DIFFERENCE(b, a), 1000, "ENET_TIME_DIFFERENCE should return the absolute difference for a < b"); - ASSERT_THAT(ENET_TIME_DIFFERENCE(a, a), 0u, "ENET_TIME_DIFFERENCE should return 0 for a == b"); + ASSERT_EQ(ENET_TIME_DIFFERENCE(a, a), 0u, "ENET_TIME_DIFFERENCE should return 0 for a == b"); // Case involving ENET_TIME_OVERFLOW constant as per user's example enet_uint32 c = 1000; enet_uint32 d = ENET_TIME_OVERFLOW; - ASSERT_THAT(ENET_TIME_DIFFERENCE(c, d), d - c, + ASSERT_EQ(ENET_TIME_DIFFERENCE(c, d), d - c, "ENET_TIME_DIFFERENCE should return the difference involving ENET_TIME_OVERFLOW"); } TEST(enet_time_get) { enet_uint32 firstTime = enet_time_get(); - ASSERT_SLEEP(100); + TEST_SLEEP(100); enet_uint32 secondTime = enet_time_get(); - ASSERT_THAT(secondTime >= firstTime, true, "enet_time_get should return increasing time"); - ASSERT_THAT(secondTime - firstTime > 90, true, "Time difference should be at least ~100ms"); + ASSERT_EQ(secondTime >= firstTime, true, "enet_time_get should return increasing time"); + ASSERT_EQ(secondTime - firstTime > 90, true, "Time difference should be at least ~100ms"); }