TapTap/FastSync
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/fix/tests-and-docs' into merge-all-v2

Browse Source 
# Conflicts:
#	tests/test_protocol.c
#	tests/test_transport_ssh.c
#	tests/test_transport_tcp.c
#	tests/test_transport_tls.c
This commit is contained in:
TapTap
2026-07-21 17:53:02 +02:00
parent 2e73c6dc13 ab4bb84ed6
commit 3b5d89fdb9
465 changed files with 34990 additions and 226 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/runner.c
+3
View File
@@ -53,6 +53,9 @@ int main() {
RUN_TEST(test_robustness);
RUN_TEST(test_stress);
RUN_TEST(test_property);
RUN_TEST(test_transport_tcp);
RUN_TEST(test_transport_ssh);
RUN_TEST(test_transport_tls);
printf("\n\033[1;36m=== TEST SUMMARY ===\033[0m\n");
printf("Total Tests Run: %d\n", tests_run);
tests/test_protocol.c
+3 -24
View File
@@ -46,7 +46,6 @@ static void test_send_receive_str() {
EXPECT_TRUE(send_str(0, ""));
/* cppcheck-suppress constVariablePointer */
char* received = receive_str(0);
EXPECT_NOT_NULL(received);
EXPECT_EQ_STR(received, "");
@@ -64,7 +63,6 @@ static void test_send_receive_str_normal() {
EXPECT_TRUE(send_str(0, "Hello, Protocol!"));
/* cppcheck-suppress constVariablePointer */
char* received = receive_str(0);
EXPECT_NOT_NULL(received);
EXPECT_EQ_STR(received, "Hello, Protocol!");
@@ -80,7 +78,6 @@ static void test_send_receive_data() {
io_set_fds(p[0], p[1]);
io_set_bwlimit(0);
/* cppcheck-suppress constVariablePointer */
unsigned char bin[] = {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0xFF};
void* buf = malloc(sizeof(bin));
EXPECT_NOT_NULL(buf);
@@ -131,9 +128,9 @@ static void test_send_receive_status() {
io_set_fds(p[0], p[1]);
io_set_bwlimit(0);
/* cppcheck-suppress constVariablePointer */
Status statuses[] = {STATUS_OK, STATUS_ERROR, STATUS_FINISHED, STATUS_NEXT,
STATUS_CHUNK, STATUS_CHECK, STATUS_DELTA_SIGNATURE, STATUS_DELTA_DATA};
Status statuses[] = {STATUS_OK, STATUS_ERROR, STATUS_FINISHED, STATUS_NEXT,
STATUS_CHUNK, STATUS_CHECK, STATUS_DELTA_SIGNATURE, STATUS_DELTA_DATA,
STATUS_KEEPALIVE, STATUS_ABORT, STATUS_CHECK_BATCH};
int count = sizeof(statuses) / sizeof(statuses[0]);
for (int i = 0; i < count; i++) {
@@ -173,23 +170,6 @@ static void test_receive_str_truncated() {
close(p[0]);
}
static void test_receive_str_oversized() {
int p[2];
EXPECT_EQ_INT(pipe(p), 0);
io_set_fds(p[0], p[1]);
io_set_bwlimit(0);
/* Send a size exceeding MAX_STRING_SIZE */
size_t huge = MAX_STRING_SIZE + 1;
EXPECT_TRUE(send_n_data(0, &huge, sizeof(size_t)));
const char* received = receive_str(0);
EXPECT_NULL(received);
close(p[0]);
close(p[1]);
}
void test_protocol() {
test_send_receive_n_data();
test_send_receive_n_data_zero();
@@ -200,5 +180,4 @@ void test_protocol() {
test_send_receive_status();
test_receive_n_data_truncated();
test_receive_str_truncated();
test_receive_str_oversized();
}
tests/test_transport_ssh.c
+9 -44
View File
@@ -1,53 +1,18 @@
#include "test_transport_ssh.h"
#include "transport_ssh.h"
#include "test_utils.h"
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include "transport_ssh.h"
/* Test client_connect_ssh with invalid destination (missing colon) */
static void test_ssh_connect_invalid_dest() {
/* Missing colon — parse_remote_dest should fail and return NULL */
/* cppcheck-suppress constVariablePointer */
Client* client = client_connect_ssh("invalid-destination-no-colon", 22);
EXPECT_NULL(client);
static void test_ssh_connect_invalid_dest_no_colon() {
Client* c = client_connect_ssh("/path/to/dest", 22);
EXPECT_NULL(c);
}
/* Test client_connect_ssh with empty destination */
static void test_ssh_connect_empty_dest() {
/* cppcheck-suppress constVariablePointer */
Client* client = client_connect_ssh("", 22);
EXPECT_NULL(client);
}
/* Test client_connect_ssh with malformed destination (just a colon).
* parse_remote_dest succeeds, ssh is exec'd and fails, but the function
* creates a Client that must be cleaned up. */
static void test_ssh_connect_malformed() {
Client* client = client_connect_ssh(":", 22);
/* ssh binary exists, so exec succeeds; the function returns a Client.
* We just verify it doesn't crash and clean up properly. */
if (client != NULL) {
client_disconnect(client);
client_delete(client);
}
EXPECT_TRUE(true);
}
/* Test client_connect_ssh with valid format but unreachable host.
* The function launches ssh which will fail to connect, returns a Client. */
static void test_ssh_connect_unreachable() {
Client* client = client_connect_ssh("nonexistent.invalid:/remote/path", 22);
if (client != NULL) {
client_disconnect(client);
client_delete(client);
}
EXPECT_TRUE(true);
static void test_ssh_connect_invalid_dest_empty() {
Client* c = client_connect_ssh("", 22);
EXPECT_NULL(c);
}
void test_transport_ssh() {
test_ssh_connect_invalid_dest();
test_ssh_connect_empty_dest();
test_ssh_connect_malformed();
test_ssh_connect_unreachable();
test_ssh_connect_invalid_dest_no_colon();
test_ssh_connect_invalid_dest_empty();
}
tests/test_transport_tcp.c
+25 -71
View File
@@ -1,89 +1,43 @@
#include "test_transport_tcp.h"
#include "transport_tcp.h"
#include "test_utils.h"
#include <stdlib.h>
#include "transport_tcp.h"
#include <unistd.h>
/* Test client_create and client_delete lifecycle */
static void test_client_create_delete() {
Client* client = client_create();
EXPECT_NOT_NULL(client);
EXPECT_EQ_INT(client->file_descriptor, -1);
EXPECT_EQ_INT(client->address.ss_family, AF_UNSPEC);
EXPECT_EQ_INT(client->ssh_child_pid, -1);
EXPECT_NULL(client->ssl);
EXPECT_NULL(client->ssl_ctx);
/* Delete should clean up without error */
client_delete(client);
static void test_server_create_ephemeral() {
Server* s = server_create(0);
EXPECT_NOT_NULL(s);
EXPECT_TRUE(s->file_descriptor >= 0);
EXPECT_EQ_INT(s->address.sin_family, AF_INET);
server_delete(&s);
EXPECT_NULL(s);
}
/* Test client_delete with NULL (safety) */
static void test_client_delete_null() {
client_delete(NULL);
EXPECT_TRUE(true);
}
/* Test server_create and server_delete lifecycle */
static void test_server_create_delete() {
/* Use port 0 to let the OS assign a port */
Server* server = server_create(0);
EXPECT_NOT_NULL(server);
EXPECT_TRUE(server->file_descriptor >= 0);
EXPECT_TRUE(server->address.ss_family == AF_INET || server->address.ss_family == AF_INET6);
EXPECT_NULL(server->ssl_ctx);
/* Clean up */
server_delete(&server);
EXPECT_NULL(server);
}
/* Test server_delete with NULL pointer */
static void test_server_delete_null_ptr() {
server_delete(NULL);
EXPECT_TRUE(true);
}
/* Test server_delete with NULL server */
static void test_server_delete_null_server() {
static void test_server_delete_null() {
Server* s = NULL;
server_delete(&s);
EXPECT_NULL(s);
}
/* Test client_create can be called multiple times */
static void test_client_create_multiple() {
Client* c1 = client_create();
Client* c2 = client_create();
EXPECT_NOT_NULL(c1);
EXPECT_NOT_NULL(c2);
EXPECT_EQ_INT(c1->file_descriptor, -1);
EXPECT_EQ_INT(c2->file_descriptor, -1);
client_delete(c1);
client_delete(c2);
static void test_client_create() {
Client* c = client_create();
EXPECT_NOT_NULL(c);
EXPECT_TRUE(c->file_descriptor >= 0);
EXPECT_EQ_INT(c->address.sin_family, AF_INET);
EXPECT_EQ_INT(c->ssh_child_pid, -1);
EXPECT_NULL(c->ssl);
EXPECT_NULL(c->ssl_ctx);
client_disconnect(c);
client_delete(c);
}
/* Test client_disconnect on a fresh client (should close socket) */
static void test_client_disconnect_fresh() {
Client* client = client_create();
EXPECT_NOT_NULL(client);
/* Disconnect should close the file descriptor */
client_disconnect(client);
/* The fd should now be invalid */
/* Verify by trying to use close() on it - should fail */
EXPECT_EQ_INT(close(client->file_descriptor), -1);
client_delete(client);
static void test_client_delete_null() {
Client* c = NULL;
client_delete(c);
}
void test_transport_tcp() {
test_client_create_delete();
test_server_create_ephemeral();
test_server_delete_null();
test_client_create();
test_client_delete_null();
test_server_create_delete();
test_server_delete_null_ptr();
test_server_delete_null_server();
test_client_create_multiple();
test_client_disconnect_fresh();
}
tests/test_transport_tls.c
+11 -68
View File
@@ -1,81 +1,24 @@
#include "test_transport_tls.h"
#include "transport_tls.h"
#include "transport_tcp.h"
#include "test_utils.h"
#include <stdlib.h>
#include <unistd.h>
#include "transport_tcp.h"
#include "transport_tls.h"
/* Test tls_global_init succeeds */
static void test_tls_global_init() {
bool ok = tls_global_init();
EXPECT_TRUE(ok);
}
/* Test tls_global_init can be called multiple times */
static void test_tls_global_init_twice() {
bool ok1 = tls_global_init();
bool ok2 = tls_global_init();
EXPECT_TRUE(ok1);
EXPECT_TRUE(ok2);
}
/* Test client_connect_tls with bad certificate path.
* The function will create a socket, try to connect to localhost,
* fail to connect (since nothing is listening), and return false.
* We don't need a server to verify the error path. */
static void test_tls_connect_bad_cert() {
/* First, init TLS globally */
tls_global_init();
Client* client = client_create();
EXPECT_NOT_NULL(client);
/* Attempt to connect to a non-existent server with bad cert paths.
* client_connect_tls will try to connect first, fail, and return false.
* Note: we use an invalid host to ensure connection failure,
* which exercises the error path before cert loading. */
bool ok = client_connect_tls(client, "127.0.0.1", 1, "/nonexistent/cert.pem",
"/nonexistent/key.pem", "/nonexistent/ca.pem");
EXPECT_FALSE(ok);
client_delete(client);
}
/* Test client_connect_tls with NULL cert paths (should still attempt connection).
* Cert/key/ca being NULL is valid — the function will attempt to create an
* SSL context without client certificates. */
static void test_tls_connect_null_paths() {
tls_global_init();
Client* client = client_create();
EXPECT_NOT_NULL(client);
/* Connect to invalid address — will fail at connect() step */
bool ok = client_connect_tls(client, "127.0.0.1", 1, NULL, NULL, NULL);
EXPECT_FALSE(ok);
client_delete(client);
}
/* Test server_create_tls with bad cert paths.
* The function should fail gracefully. */
static void test_tls_server_bad_cert() {
tls_global_init();
Server* server = server_create(0);
EXPECT_NOT_NULL(server);
/* Load bad cert paths — should fail and return false */
bool ok = server_create_tls(server, "/nonexistent/cert.pem", "/nonexistent/key.pem", NULL);
EXPECT_FALSE(ok);
server_delete(&server);
static void test_server_create_tls_without_certs() {
Server* s = server_create(0);
EXPECT_NOT_NULL(s);
bool ok = server_create_tls(s, NULL, NULL, NULL);
EXPECT_TRUE(ok);
EXPECT_NOT_NULL(s->ssl_ctx);
server_delete(&s);
EXPECT_NULL(s);
}
void test_transport_tls() {
test_tls_global_init();
test_tls_global_init_twice();
test_tls_connect_bad_cert();
test_tls_connect_null_paths();
test_tls_server_bad_cert();
test_server_create_tls_without_certs();
}