C09-C13 coverage, issue fixes, -42 forbidden-function check

[skyreks00]

C09, C10, C11, C12 and C13 had no tests at all before this — 41 exercises across the five modules, each one checked against both a correct reference implementation and a deliberately broken one before being kept.

New coverage

• C09: libft builds libft.a via the student's own libft_creator.sh script and links a harness against it; Makefile drops a grader-supplied srcs/ + includes/ft.h fixture and drives make/clean/fclean/re; ft_split
• C10: display_file, cat, tail, hexdump — built with make and driven through popen, like C06's argv exercises. ft_hexdump -C's byte layout was checked against the real system hexdump across a dozen sizes before being baked in as a self-contained reference generator
• C11 (8), C12 (18), C13 (8) — straight from the official subject PDFs. C12/C13 share one ft_list.h / ft_btree.h in mini-moul/utils/ instead of duplicating the header per exercise

Fixes #11, #15, #16, #18, #27, #28, #29, #30, #31, #33, #35, #40, #41, #42, #43

The two segfault-class bugs

ft_strlcat's test built dest sized to strlen(dest), but the function is entitled to assume dest has size bytes available — which can be a lot bigger than the initial string. A correct implementation could write straight past the buffer.

// before — sized to the initial content, not to size
char dest[strlen(tests[i].dest) + 1];

// after — sized to whichever is bigger
size_t dest_cap = strlen(tests[i].dest) + 1;
if ((size_t)tests[i].size > dest_cap)
    dest_cap = (size_t)tests[i].size;
char dest[dest_cap];

ft_strcat's test had the opposite problem: dest was a fixed array inside a struct literal, which C zero-initializes for you — so a student who forgot to null-terminate their result would still pass, since the missing byte was already zero.

// poison past the initial content so a missing null terminator
// shows up instead of being masked by an already-zero buffer
memset(dest, 'Z', sizeof(dest));
strcpy(dest, tests[i].initial_dest);

Everything else that was actually broken

• ft_ten_queens_puzzle was still a stub that didn't even compile, and separately expected 92 solutions (the eight-queens answer) instead of 724
• ft_strcapitalize never tested the subject's own rule that a digit inside a word blocks capitalization of what follows: 123AA → 123aa, not 123Aa
• ft_strlcpy never tested size=0, a classic off-by-one
• ft_atoi only tested plain spaces even though the subject says isspace(3), and separately pinned a specific overflow/underflow result the subject explicitly calls undefined — removed those two cases
• 0 ** 0 was untested for both power exercises, even though the subject explicitly defines it as 1
• ft_sqrt never got an INT_MAX case — a naive while (i * i < nb) i++; overflows and loops forever there
• ft_convert_base never tested nbr="0", which breaks any implementation that divides until zero and never enters the loop for an input already at zero

Harness bugs affecting every exercise, not just the new ones

test.sh's "strict compile" step was compiling its own test file — which already has #include <string.h> etc. — instead of the student's file, so a missing include in the student's own code silently passed:

- cc -Wall -Werror -Wextra -o test1 $(ls $assignment/*.c | head -n 1)
+ cc -std=gnu99 -Wall -Werror -Wextra -c "$source_file" -o moul_check.o

It also had no timeout anywhere around test execution, so one hanging binary (the ft_sqrt case above, for instance) froze the entire run forever. There's now a 10 second timeout around it, and the exit code — which used to always be 0 regardless of pass/fail — now reflects the real result.

mini-moul.sh crashed on every single invocation:

if detect_assignment; then
  cp -R ~/mini-moulinette/mini-moul mini-moul
  run_norminette        # called here...
  ...
run_norminette() {      # ...but only defined down here
  ...

Bash doesn't hoist function definitions, so this never worked. Fixed, plus lowercase folder name support (c00-c13, #18) and excluded mini-moul/ itself from the norminette scan — it doesn't follow the Norm and was never meant to be graded against it.

New: -42 for forbidden functions (#30)

Each exercise's own subject lists which functions are allowed — most say "None". Nothing in this repo checked that a student wasn't just calling printf where only write was allowed. Every exercise's test file now carries that list straight from its subject:

// ALLOWED_FUNCTIONS: malloc, free

strip_c.c blanks out comments and string/char literal contents from the student's source first, so a function name mentioned in a comment or a string doesn't get flagged, and check_forbidden.sh greps what's left for calls to a fixed list of common libc functions not on that exercise's list. A hit marks the exercise -42 and forces the whole run's final score to -42/100, Status: CHEATER — matching the subject's own rule word for word ("Cheaters get -42, and this grade is non-negotiable"). It's grep-based, not a real parser, so it won't catch a function called only through a pointer, but it covers the obvious case.

Validated against two complete, real student piscine repos

Checking every new test against a reference and a broken implementation doesn't catch problems that only show up on real, organically-written code. So I cloned two full C00–C13 student repos and ran the actual mini-moul.sh entry point (not just test.sh) against every module, treating each failure as either a real student bug to leave alone, or a real bug in this harness.

• test.sh's isolated compile check was a blind cc -c on whatever .c files sat directly in the exercise folder — anyone who organizes their code into srcs/ + includes/ and drives it with their own Makefile failed wholesale. It now prefers make -s when a Makefile exists, treats zero .c files as fine for header-only exercises (C08 asks for a .h and nothing else), and adds -I to the harness's own utils/ directory so a student who doesn't keep a local copy of ft_list.h/ft_btree.h/ft_stock_str.h isn't penalized for it
• do-op.c (C11/ex05) had the same blind-wildcard build problem in its own compile step, fixed the same way
• check_forbidden.sh scanned every .c file sitting in the exercise directory, so a student keeping a local copy of an earlier exercise's deliverable in the same folder (so it compiles standalone) got flagged for that file's calls. It now scans only the specific file the exercise's test #includes — or, for C08's header-only exercises, only the header — and falls back to the old wildcard scan solely for the do-op/C10-style programs that genuinely build every .c file in the directory
• The most serious one: C09/ex01's Makefile test writes its own srcs/ + includes/ fixture over the student's files (the real subject says the grader supplies them) and deletes it afterward. One of the two real repos checks its own srcs//includes/ into git anyway — the very first run against it permanently deleted those files. It now backs up whatever was already there before writing the fixture and restores it afterward:

static void backup_existing(void)
{
    system("mv ../ex01/srcs ../ex01/moul_srcs_backup 2> /dev/null");
    system("mv ../ex01/includes ../ex01/moul_includes_backup 2> /dev/null");
    system("mv ../ex01/libft.a ../ex01/moul_libft_backup.a 2> /dev/null");
}

• Two smaller test crashes: C07/ex02's ft_ultimate_range test freed an uninitialized pointer when a student's implementation legitimately never wrote through its output parameter, crashing the whole test binary instead of just failing that case; C07/ex01 printed the wrong array index in its failure message (result[i] instead of result[0]) — cosmetic, never affected pass/fail

[gutierreztomaspro-cmd]

Thanks a lot for your work !