da7e/42-LibUnit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Prettier output and some fixes (#4)

Browse Source 
* feat: tab results

* feat: more colors

* style: norm

* fix: patch a spacing bug

* fix: patch a small issue

* fix: patch some leaks

* style: norm
This commit is contained in:
Erwann Lagouche
2026-01-25 18:20:20 +01:00
committed by GitHub
parent d8824f7890
commit 677028dcbb
29 changed files with 225 additions and 166 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
framework/libunit.c
View File

@@ -6,7 +6,7 @@
/* By: dgaillet <dgaillet@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/24 12:43:35 by dgaillet #+# #+# */
/* Updated: 2026/01/25 15:15:05 by elagouch ### ########.fr */
/* Updated: 2026/01/25 18:15:25 by elagouch ### ########.fr */
/* */
/* ************************************************************************** */
@@ -16,39 +16,49 @@
#include <sys/wait.h>
#include <unistd.h>
int parent_helper(int ffd, struct s_helper *h, const char *fn_name,
static int parent_helper(int ffd, struct s_helper *h, const char *fn_name,
t_unit_test *test_list)
{
int status;
int status;
int ffdst[2];
pid_t caught_pid;
h->wpid = waitpid(h->wpid, &status, WCONTINUED);
if (h->wpid < 0)
return (-1);
h->ok_tests += interpret_status(ffd, status, fn_name, get_test_at(test_list,
h->i)->title);
caught_pid = 0;
while (caught_pid != h->wpid)
{
caught_pid = wait(&status);
if (caught_pid < 0)
return (-1);
}
ffdst[0] = ffd;
ffdst[1] = status;
h->ok_tests += interpret_status(ffdst, fn_name, get_test_at(test_list,
h->i)->title, test_list->max_len);
return (0);
}
int child_helper(t_unit_test *test_list, t_h h)
static int child_helper(t_unit_test *test_list, t_h h, int ffd)
{
int fd;
int res;
t_unit_test *test;
int fd;
int res;
t_unit_test *test;
fd = open("/dev/null", O_WRONLY);
if (!fd)
return (-1);
fd = open("/dev/null", O_WRONLY);
if (!fd)
return (-1);
if (dup2(fd, STDOUT_FILENO) < 0)
return (-1);
test = get_test_at(test_list, h.i);
if (test->timeout)
alarm(test->timeout);
return (-1);
test = get_test_at(test_list, h.i);
if (test->timeout)
alarm(test->timeout);
res = test->func();
close(fd);
exit(res);
close(fd);
close(ffd);
clear_tests(&test_list);
exit(res);
}
int handle_out(const char *fn_name)
static int handle_out(const char *fn_name)
{
char *tmp;
int fd;
@@ -70,18 +80,20 @@ int launch_tests(t_unit_test *test_list, const char *fn_name)
h.i = -1;
ffd = handle_out(fn_name);
if (ffd < 0)
return (1);
return (-1);
while (++h.i < (int)count_tests(test_list))
{
h.wpid = fork();
if (h.wpid < 0)
return (1);
else if (h.wpid == 0 && child_helper(test_list, h) < 0)
return (1);
return (-1);
else if (h.wpid == 0 && child_helper(test_list, h, ffd) < 0)
return (-1);
else if (parent_helper(ffd, &h, fn_name, test_list))
return (1);
return (-1);
}
print_passed_test(ffd, h.ok_tests, test_list);
close(ffd);
if (h.ok_tests != count_tests(test_list))
return (-1);
return (0);
}

9
framework/libunit.h
View File

@@ -6,7 +6,7 @@
/* By: elagouch <elagouch@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/24 14:38:40 by elagouch #+# #+# */
/* Updated: 2026/01/25 15:09:41 by elagouch ### ########.fr */
/* Updated: 2026/01/25 17:33:21 by elagouch ### ########.fr */
/* */
/* ************************************************************************** */
@@ -25,7 +25,8 @@ typedef struct s_unit_test
char *title;
int (*func)(void);
struct s_unit_test *next;
unsigned int timeout;
unsigned int timeout;
size_t max_len;
} t_unit_test;
/**
@@ -74,8 +75,8 @@ typedef struct s_helper
int i;
} t_h;
size_t interpret_status(int ffd, int status,
const char *fn_name, char *test_name);
size_t interpret_status(int ffdst[2], const char *fn_name,
char *test_name, size_t spaces);
void print_passed_test(int ffd, size_t ok_tests,
t_unit_test *test_list);

69
framework/libunit_logger.c
View File

@@ -6,63 +6,88 @@
/* By: elagouch <elagouch@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/25 14:26:54 by elagouch #+# #+# */
/* Updated: 2026/01/25 14:56:06 by elagouch ### ########.fr */
/* Updated: 2026/01/25 17:35:53 by elagouch ### ########.fr */
/* */
/* ************************************************************************** */
#include "libunit.h"
#include <stdio.h>
static void print_tabbed(int fd1, int fd2, char *s, size_t expected_len)
{
size_t i;
size_t l;
l = ft_strlen(s);
ft_putstr_fd(s, fd1);
ft_putstr_fd(s, fd2);
i = 0;
while (l <= expected_len && i < (expected_len - l))
{
ft_putchar_fd(' ', fd1);
ft_putchar_fd(' ', fd2);
i++;
}
}
static void print_wtermsig(int ffd, int signal)
{
static char *sigs[15];
char *msg;
char *msg;
sigs[4] = "SIGKILL";
sigs[6] = "SIGABRT";
sigs[7] = "SIGBUS";
sigs[8] = "SIGFPE";
sigs[9] = "SIGKILL";
sigs[11] = "SIGSEGV";
sigs[13] = "SIGPIPE";
sigs[14] = "TIMEOUT";
ft_putstr_fd("[\x1B[33m", 1);
ft_putstr_fd("[", ffd);
if ((signal >= 6 && signal <=8) || signal == 4 || signal == 11 || (signal >= 13 && signal <= 14))
msg = sigs[signal];
else
msg = "UNKNOWN";
if ((signal >= 6 && signal <= 9) || signal == 11 || (signal >= 13
&& signal <= 14))
msg = sigs[signal];
else
msg = "UNKNOWN";
ft_putstr_fd(msg, 1);
ft_putstr_fd(msg, ffd);
ft_putstr_fd("\x1B[0m]\n", 1);
ft_putstr_fd("]\n", ffd);
}
size_t interpret_status(int ffd, int status, const char *fn_name,
char *test_name)
static void interpret_status_print(const char *fn_name, int ffd,
char *test_name, size_t max_len)
{
ft_putstr_fd("\x1B[94m", 1);
ft_putstr_fd((char *)fn_name, 1);
ft_putstr_fd((char *)fn_name, ffd);
ft_putstr_fd(" : ", 1);
ft_putstr_fd("\x1B[90m : \x1B[0m", 1);
ft_putstr_fd(" : ", ffd);
ft_putstr_fd(test_name, 1);
ft_putstr_fd(test_name, ffd);
ft_putstr_fd(" : ", 1);
ft_putstr_fd(" : ", ffd);
if (WIFEXITED(status))
print_tabbed(1, ffd, test_name, max_len);
ft_putstr_fd("\x1B[90m : \x1B[0m", 1);
ft_putstr_fd(": ", ffd);
}
size_t interpret_status(int ffdst[2], const char *fn_name, char *test_name,
size_t max_len)
{
interpret_status_print(fn_name, ffdst[0], test_name, max_len);
if (WIFEXITED(ffdst[1]))
{
if (WEXITSTATUS(status))
if (WEXITSTATUS(ffdst[1]))
{
ft_putstr_fd("[\x1B[31m\x1B[1mKO\x1B[0m]\n", 1);
ft_putstr_fd("[KO]\n", ffd);
ft_putstr_fd("[KO]\n", ffdst[0]);
}
else
{
ft_putstr_fd("[\x1B[32mOK\x1B[0m]\n", 1);
ft_putstr_fd("[OK]\n", ffd);
ft_putstr_fd("[OK]\n", ffdst[0]);
return (1);
}
}
else if (WIFSIGNALED(status))
print_wtermsig(ffd, WTERMSIG(status));
else if (WIFSIGNALED(ffdst[1]))
print_wtermsig(ffdst[0], WTERMSIG(ffdst[1]));
return (0);
}
@@ -81,6 +106,6 @@ void print_passed_test(int ffd, size_t ok_tests, t_unit_test *test_list)
ft_putchar_fd('/', ffd);
ft_putnbr_fd((int)total, 1);
ft_putnbr_fd((int)total, ffd);
ft_putstr_fd("\x1B[0m tests succeeded\n\n", 1);
ft_putstr_fd(" tests succeeded\n\n", ffd);
ft_putstr_fd("\x1B[0m tests passed\n\n", 1);
ft_putstr_fd(" tests passed\n\n", ffd);
}

40
framework/libunit_util.c
View File

@@ -6,7 +6,7 @@
/* By: elagouch <elagouch@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/24 14:35:57 by elagouch #+# #+# */
/* Updated: 2026/01/25 15:11:24 by elagouch ### ########.fr */
/* Updated: 2026/01/25 18:03:11 by elagouch ### ########.fr */
/* */
/* ************************************************************************** */
@@ -39,7 +39,8 @@ t_unit_test *get_last(t_unit_test *head)
/**
* @brief util function to allocate a new test
*/
static t_unit_test *alloc_test(const char *title, int (*test_func)(void), unsigned int timeout)
static t_unit_test *alloc_test(const char *title, int (*test_func)(void),
unsigned int timeout)
{
t_unit_test *p;
@@ -47,49 +48,52 @@ static t_unit_test *alloc_test(const char *title, int (*test_func)(void), unsign
p->title = ft_strdup(title);
p->func = test_func;
p->next = NULL;
p->timeout = timeout;
p->timeout = timeout;
p->max_len = 0;
return (p);
}
size_t load_test(t_unit_test **head_ptr, const char *title,
int (*test_func)(void), unsigned int timeout)
{
t_unit_test *p;
t_unit_test *last;
size_t tlen;
if (!head_ptr)
return (-1);
tlen = ft_strlen(title);
if (!*head_ptr)
{
p = alloc_test(title, test_func, timeout);
if (!p)
*head_ptr = alloc_test(title, test_func, timeout);
if (!*head_ptr)
return (-1);
*head_ptr = p;
(*head_ptr)->max_len = ft_strlen(title);
return (0);
}
last = get_last(*head_ptr);
last->next = alloc_test(title, test_func, timeout);
if (!last->next)
return (-1);
if ((*head_ptr)->max_len < tlen)
(*head_ptr)->max_len = tlen;
return (0);
}
void clear_tests(t_unit_test **head_ptr)
{
t_unit_test *head;
t_unit_test *current;
t_unit_test *next;
next = *head_ptr;
head = NULL;
while (head)
if (!head_ptr)
return ;
current = *head_ptr;
while (current)
{
head = *head_ptr;
next = head->next;
head->next = NULL;
free(head->title);
head->title = NULL;
head->func = NULL;
head = next;
next = current->next;
if (current->title)
free(current->title);
free(current);
current = next;
}
*head_ptr = NULL;
}