We've built up similarly *dependency-injected* interfaces to the keyboard,
mouse, disk and network.
1. Support for testing side-effects like performance, deadlock-freedom,
race-freeness, memory usage, etc. Mu's *white-box tests* can check not just
the results of a function call, but also the presence or absence of
specific events in the log of its progress. For example, here's a test that
our string-comparison function doesn't scan individual characters unless it
has to:
Another example: if a sort function logs each swap, a performance test can
check that the number of swaps doesn't quadruple when the size of the input
doubles.
Besides expanding the scope of tests, this ability also allows more
radical refactoring without needing to modify tests. All Mu's tests call a
top-level function rather than individual sub-systems directly. As a result
the way the subsystems are invoked can be radically changed (interface
changes, making synchronous functions asynchronous, etc.). As long as the
new versions emit the same implementation-independent events in the logs,
the tests will continue to pass. ([More information.](http://akkartik.name/post/tracing-tests))
1. Organizing code and tests in layers of functionality, so that outsiders can
build simple and successively more complex versions of a project, gradually
enabling more peripheral features. Think of it as a cleaned-up `git log`
for the project. ([More information.](http://akkartik.name/post/wart-layers))
These mechanisms exist in the context of a low-level statement-oriented
language (like Basic, or Assembly). The language is as powerful as C for
low-level pointer operations and manual memory management, but much safer,
paying some run-time overhead to validate pointers. It also provides a number
of features usually associated with higher-level languages: strong
type# To check our support for screens in scenarios, rewrite tests from print.mu
scenario print-character-at-top-left-2 [
local-scope
assume-screen 3/width, 2/height
run [
a:char <- copy 97/a
screen <- print screen, a
]
screen-should-contain [
.a .
. .
]
]
scenario clear-line-erases-printed-characters-2 [
local-scope
assume-screen 5/width, 3/height
# print a character
a:char <- copy 97/a
screen <- print screen, a
# move cursor to start of line
screen <- move-cursor screen, 0/row, 0/column
run [
screen <- clear-line screen
]
screen-should-contain [
. .
. .
. .
]
]
scenario scroll-screen [
local-scope
assume-screen 3/width, 2/height
run [
a:char <- copy 97/a
move-cursor screen, 1/row, 2/column
screen <- print screen, a
screen <- print screen, a
]
screen-should-contain