71e4f38129
Baremetal is now the default build target and therefore has its sources
at the top-level. Baremetal programs build using the phase-2 Mu toolchain
that requires a Linux kernel. This phase-2 codebase which used to be at
the top-level is now under the linux/ directory. Finally, the phase-2 toolchain,
while self-hosting, has a way to bootstrap from a C implementation, which
is now stored in linux/bootstrap. The bootstrap C implementation uses some
literate programming tools that are now in linux/bootstrap/tools.
So the whole thing has gotten inverted. Each directory should build one
artifact and include the main sources (along with standard library). Tools
used for building it are relegated to sub-directories, even though those
tools are often useful in their own right, and have had lots of interesting
programs written using them.
A couple of things have gotten dropped in this process:
- I had old ways to run on just a Linux kernel, or with a Soso kernel.
No more.
- I had some old tooling for running a single test at the cursor. I haven't
used that lately. Maybe I'll bring it back one day.
The reorg isn't done yet. Still to do:
- redo documentation everywhere. All the README files, all other markdown,
particularly vocabulary.md.
- clean up how-to-run comments at the start of programs everywhere
- rethink what to do with the html/ directory. Do we even want to keep
supporting it?
In spite of these shortcomings, all the scripts at the top-level, linux/
and linux/bootstrap are working. The names of the scripts also feel reasonable.
This is a good milestone to take stock at.
124 lines
3.6 KiB
C++
124 lines
3.6 KiB
C++
//: A simple test harness. To create new tests, define functions starting with
|
|
//: 'test_'. To run all tests so defined, run:
|
|
//: $ ./bootstrap test
|
|
//:
|
|
//: Every layer should include tests, and can reach into previous layers.
|
|
//: However, it seems like a good idea never to reach into tests from previous
|
|
//: layers. Every test should be a contract that always passes as originally
|
|
//: written, regardless of any later layers. Avoid writing 'temporary' tests
|
|
//: that are only meant to work until some layer.
|
|
|
|
:(before "End Types")
|
|
typedef void (*test_fn)(void);
|
|
:(before "Globals")
|
|
// move a global ahead into types that we can't generate an extern declaration for
|
|
const test_fn Tests[] = {
|
|
#include "test_list" // auto-generated; see 'build*' scripts
|
|
};
|
|
|
|
:(before "End Globals")
|
|
bool Run_tests = false;
|
|
bool Passed = true; // set this to false inside any test to indicate failure
|
|
|
|
:(before "End Includes")
|
|
#define CHECK(X) \
|
|
if (Passed && !(X)) { \
|
|
cerr << "\nF - " << __FUNCTION__ << "(" << __FILE__ << ":" << __LINE__ << "): " << #X << '\n'; \
|
|
Passed = false; \
|
|
return; /* Currently we stop at the very first failure. */ \
|
|
}
|
|
|
|
#define CHECK_EQ(X, Y) \
|
|
if (Passed && (X) != (Y)) { \
|
|
cerr << "\nF - " << __FUNCTION__ << "(" << __FILE__ << ":" << __LINE__ << "): " << #X << " == " << #Y << '\n'; \
|
|
cerr << " got " << (X) << '\n'; /* BEWARE: multiple eval */ \
|
|
Passed = false; \
|
|
return; /* Currently we stop at the very first failure. */ \
|
|
}
|
|
|
|
:(before "End Reset")
|
|
Passed = true;
|
|
|
|
:(before "End Commandline Parsing")
|
|
if (argc > 1 && is_equal(argv[1], "test")) {
|
|
Run_tests = true; --argc; ++argv; // shift 'test' out of commandline args
|
|
}
|
|
|
|
:(before "End Main")
|
|
if (Run_tests) {
|
|
// Test Runs
|
|
// we run some tests and then exit; assume no state need be maintained afterward
|
|
|
|
long num_failures = 0;
|
|
// End Test Run Initialization
|
|
time_t t; time(&t);
|
|
cerr << "C tests: " << ctime(&t);
|
|
for (size_t i=0; i < sizeof(Tests)/sizeof(Tests[0]); ++i) {
|
|
//? cerr << "running " << Test_names[i] << '\n';
|
|
run_test(i);
|
|
if (Passed) cerr << '.';
|
|
else ++num_failures;
|
|
}
|
|
cerr << '\n';
|
|
// End Tests
|
|
if (num_failures > 0) {
|
|
cerr << num_failures << " failure"
|
|
<< (num_failures > 1 ? "s" : "")
|
|
<< '\n';
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
:(after "End Main")
|
|
//: Raise other unrecognized sub-commands as errors.
|
|
//: We couldn't do this until now because we want `./bootstrap test` to always
|
|
//: succeed, no matter how many layers are included in the build.
|
|
cerr << "nothing to do\n";
|
|
return 1;
|
|
|
|
:(code)
|
|
void run_test(size_t i) {
|
|
if (i >= sizeof(Tests)/sizeof(Tests[0])) {
|
|
cerr << "no test " << i << '\n';
|
|
return;
|
|
}
|
|
reset();
|
|
// End Test Setup
|
|
(*Tests[i])();
|
|
// End Test Teardown
|
|
}
|
|
|
|
//: Convenience: run a single test
|
|
:(before "Globals")
|
|
// Names for each element of the 'Tests' global, respectively.
|
|
const string Test_names[] = {
|
|
#include "test_name_list" // auto-generated; see 'build*' scripts
|
|
};
|
|
:(after "Test Runs")
|
|
string maybe_single_test_to_run = argv[argc-1];
|
|
for (size_t i=0; i < sizeof(Tests)/sizeof(Tests[0]); ++i) {
|
|
if (Test_names[i] == maybe_single_test_to_run) {
|
|
run_test(i);
|
|
if (Passed) cerr << ".\n";
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
//: A pending test that also serves to put our test harness through its paces.
|
|
|
|
:(code)
|
|
void test_is_equal() {
|
|
CHECK(is_equal("", ""));
|
|
CHECK(!is_equal("", "foo"));
|
|
CHECK(!is_equal("foo", ""));
|
|
CHECK(!is_equal("f", "bar"));
|
|
CHECK(!is_equal("bar", "f"));
|
|
CHECK(!is_equal("bar", "ba"));
|
|
CHECK(!is_equal("ba", "bar"));
|
|
CHECK(is_equal("bar", "bar"));
|
|
}
|
|
|
|
:(before "End Includes")
|
|
#include <stdlib.h>
|