* alisp.org: reset state of Unit tests to TODO
* alisp.org: take sv_t tasks out of the backlog and set to WIP
* sv: add prototypes for sv_chop_{left,right} and sv_substr
* sv: implement sv_chop_{left, right} and sv_substr
* sv: sv_till and sv_while
* sv: add sv_truncate
When you just want to decrease to a specific size, sv_chop_right is a
bit cumbersome.
* alisp.org: Update and adjust
* 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
By default we should test all our code for regressions. I'm always
running the examples anyway to test new features, so we should have
that recipe run afterwards.
If a test fails, that's first priority to fix.
If an example fails, time to continue working.
If you allocate a vector on the stack and default initialise
it (i.e. {0}), then by default "is_inlined" = 0. This is bad, as
technically speaking we should expect the vector to attempt to use
it's small inline buffer for vector operations before going onto the
heap - this will mess up our functions. So here I adjust the name to
make default stack based allocation a bit easier.
Since most use cases require indexing the data directly, and the macro
implies you're retrieving data from it, may as well take the index.
If you wanted a pointer to that data, &VEC_GET(vec, index, type) works
just fine.
Easier to iterate through, O(1) amortized registering just like the
Linked List.
VEC_SIZE just makes it easier to iterate through a vector of specially
typed elements.
Main reason to have this at all is to make char-by-char reading
feasible. This occurs at `stream_chunk`, and previously if we passed
in STDIN for `stream_init_file`, STDIN will only terminate once
STREAM_DEFAULT_CHUNK number of characters have been fed into the pipe.
This isn't desirable for STDIN (we really want to read char-by-char
for expressions), nor would it necessarily be desirable in network
applications. So any stream marked STREAM_TYPE_PIPE will only chunk
character-by-character rather than genuine chunks.
