tests: refactor testing and implement a bunch of tests

* tests: split of symtable testing into its own suite

makes sense to be there, not in the lisp API

* tests: Added string view suite

sv_copy is the only function, but we may have others later.

* tests: Meaningful and pretty logging for tests

* tests: slight cleanliness

* tests: c23 allows you to inline stack allocated arrays in struct decls

* test: Added definition to make default testing less verbose

TEST_VERBOSE is a preprocesser directive which TEST is dependent on.
By default it is 0, in which case TEST simply fails if the condition
is not true.  Otherwise, a full log (as done previously) is made.

* Makefile: added mode flag for full logs

MODE=full will initialise a debug build with all logs, including test
logs.  Otherwise, MODE=debug just sets up standard debug build with
main logs but no testing logs.  MODE=release optimises and strips all
logs.

* tests: fix size of LISP_API_SUITE tests

* test_lisp_api: int_test -> smi_test, added smi_oob_test

* test_lisp_api: sym_test -> sym_fresh_test

* test_lisp_api: added sym_unique_test

* alisp.org: Added some tasks

* symtable: sym_table_cleanup -> sym_table_free

* lisp: split off lisp_free as it's own function

lisp_free will do a shallow clean of any object, freeing its
associated memory.  It won't recur through any containers, nor will it
freakout if you give it something that is constant (symbols, small
integers, NIL, etc).

* test_lisp_api: added sys_test

* test_stream: basic skeleton

* test_stream: implement stream_test_string

* test_stream: Enable only stream_test_string

* tests: enable STREAM_SUITE

* sv: fix possible runtime issue with NULL SV's in sv_copy

* alisp.org: add TODOs for all the tests required for streams

* tests: Better suite creation

While the previous method of in-lining a stack allocated array of
tests into the suite struct declaration was nice, we had to update
size manually.

This macro will allow us to just append new tests to the suite without
having to care for that.  It generates a uniquely named variable for
the test array, then uses that test array in the suite declaration.
Nice and easy.

* test: TEST_INIT macro as a prologue for any unit test

* main: Put all variable declarations at start of main to ensure decl

There is a chance that /end/ is jumped to without the FILE pointer or
stream actually being declared.  This deals with that.

* stream: Make stream name a constant cstr

We don't deal with the memory for it anyway.

* stream: do not initialise file streams with a non-empty vector

Because of the not_inlined trick, a 0 initialised SBO vector is
completely valid to use if required.  Future /vec_ensure/'s will deal
with it appropriately.  So there's no need to initialise the vector
ahead of time like this.

* test_stream: implement stream_test_file

We might need to setup a prelude for initialising a file in the
filesystem for testing here - not only does stream_test_file need it,
but I see later tests requiring an equivalence check for files and
strings (variants of a stream).

* test_stream: setup prologue and epilogue as fake tests in the suite

Standard old test functions, but they don't call TEST_INIT or
TEST_PASSED.  They're placed at the start and at the end of the test
array.

Those macros just do printing anyway, so they're not necessary.

* tests: TEST_INIT -> TEST_START, TEST_PASSED -> TEST_END

* tests: TEST_START only logs if TEST_VERBOSE is enabled.

* test_lisp_api: "cons'" -> "conses"

* alisp.org: Mark off completed stream_test_file

* test_stream: implement stream_test_peek_next

* test_stream: randomise filename

Just to make sure it's not hardcoded or anything.

* test_stream: make filename bigger, and increase the random alphabet

* test: seed random number generator

* test_stream: don't write null terminator to mock file

* stream: stream_seek will do clamped movement if offset is invalid

If a forward/backward offset is too big, we'll clamp to the edges of
the file rather than failing completely.  We return the number of
bytes moved so callers can still validate, but the stream API can now
deal with these situations a bit more effectively.

* test_stream: implement stream_test_seek

* stream: ensure stream_stop resets the FILE pointer if STREAM_TYPE_FILE

* stream: stream_substr's call to stream_seek_forward refactored

Following stream_seek_forward's own refactor, where we get offsets
back instead of just a boolean, we should verify that offset.

* main: put stream_stop before FILE pointer close

As stream_stop requires a valid FILE pointer (fseek), we need to do it
before we close the pipe.

* test_vec: vec_test_substr -> vec_test_gen_substr

* test_stream: implement stream_test_substr

* alisp: add TODO for sv_t

include/alisp/lisp.h

@@ -49,6 +49,8 @@ vec_t *as_vec(lisp_t *);
 lisp_t *car(lisp_t *);
 lisp_t *cdr(lisp_t *);
 
+void lisp_free(lisp_t *);
+
 #endif
 
 /* Copyright (C) 2026 Aryadev Chavali

include/alisp/stream.h

@@ -40,7 +40,7 @@ typedef struct
 typedef struct
 {
   stream_type_t type;
-  char *name;
+  const char *name;
   u64 position;
   union
   {
@@ -51,9 +51,9 @@ typedef struct
 
 #define STREAM_DEFAULT_CHUNK 64
 
-stream_err_t stream_init_string(stream_t *, char *, sv_t);
-stream_err_t stream_init_pipe(stream_t *, char *, FILE *);
-stream_err_t stream_init_file(stream_t *, char *, FILE *);
+stream_err_t stream_init_string(stream_t *, const char *, sv_t);
+stream_err_t stream_init_pipe(stream_t *, const char *, FILE *);
+stream_err_t stream_init_file(stream_t *, const char *, FILE *);
 void stream_stop(stream_t *);
 
 // End of Content (i.e. we've consumed all cached content/file)
@@ -66,9 +66,9 @@ char stream_next(stream_t *);
 // Peek current character, do not push position
 char stream_peek(stream_t *);
 // Move forward or backward in the stream, return success of operation
-bool stream_seek(stream_t *, i64);
-bool stream_seek_forward(stream_t *, u64);
-bool stream_seek_backward(stream_t *, u64);
+u64 stream_seek(stream_t *, i64);
+u64 stream_seek_forward(stream_t *, u64);
+u64 stream_seek_backward(stream_t *, u64);
 
 // Return a relative substring of a given size
 sv_t stream_substr(stream_t *, u64);

include/alisp/symtable.h

@@ -22,7 +22,7 @@ typedef struct
 
 void sym_table_init(sym_table_t *);
 char *sym_table_find(sym_table_t *, sv_t);
-void sym_table_cleanup(sym_table_t *);
+void sym_table_free(sym_table_t *);
 
 #endif