anchor.diff:  arguments. A *test* consists of one or more OS/161 commands along with
   metadata, `sys161` configuration, and possibly some additional `test161` runtime
   configuration. Tests can include one or more *tags*, which allow related tests
  -to be grouped and run together. *Targets* are a set of tests that are run
  +to be grouped and run together. *Targets* consist of a set of tests that are run
   together and allow point values to be assigned to tests.
   
   ==== Listing Tests, Targets, and Tags
  
positive.code: Some tests will consist of multiple commands, and such tests are designed to
  stress test your system.
  
  === [[targets]]Targets
  
  Target files (`*.tt`) are located in the `targets/` directory in your test161 root
  directory. Targets specify which tests are run for each assignment, and
  how the scoring is distributed. When you `test161 submit` your assignments, you will
  specify which target to submit to.
  
  == Features
  
  === Testfile Syntactic Sugar
  
  A line starting with `$` will be run in the shell and start the shell as
  needed. Lines not starting with `$` are run from the kernel prompt and get
  there if necessary by exiting the shell. `sys161` shuts down cleanly without
  requiring the test manually exit the shell and kernel, as needed.
  
  So this test:
  ....
  $ /bin/true
  ....
  
  Expands to:
  ....
  s
  /bin/true
  exit
  q
  ....
  
  *Note that commands run in the shell _must_ be prefixed with `$`.* Otherwise
  `test161` will consider them a kernel command and exit the shell before
  running them. For example:
  
  This test is probably not what you want:
  ....
  s
  /bin/true
  ....
  
  Because it will expand to:
  ....
  s
  exit
  /bin/true # not a kernel command
  ....
  
  But this is so much simpler, right?
  ....
  $ /bin/true
  ....
  
  === [[tags]]Test Tags
  Optionally, tests can have one or more tags. `test161` can be invoked to run these tests
  as a group with `test161 run <tag>`.
  
  === Progress Tracking Using `stat161` Output
  
  
negative.code: * `sys161` and `disk161` in the path.
  * Git version >= 2.3.0.
  
  
  == Commands, Tests, and Targets
  
  `test161` uses a http://yaml.org[YAML]-based configuration system, with
  configuration files located across subdirectories of your `test161`
  directory. The anatomy of this configuration directory is as follows:
  
  * *commands/*: *.tc files containing OS/161 command specification. Each .tc
  file usually contains multiple related commands.
  
  * *targets/*: *.tt files containing target definitions, one per target.
  
  * *tests/*: *.t files containing test specification, one per test. This
  directory will contain subdirectories used to organize related tests.
  
  === Commands
  
  The basic unit in `test161` is a command, such as `lt1` for running Lock Test 1,
  or `sp1` to run the whalemating test.  Information about what to
  expect when running these commands, as well as what input/output they expect
  is specified in the `commands` directory in your test161 root directory.
  All .tc files in this directory will be loaded, and commands must only be
  specified once.
  
  The following is the full syntax for a commands file:
  
  [source,yaml]
  ----
  # Each commands file consists of a collection of templates. An * indicates the
  # default option.
  templates:
     # Command name/id. For userland tests, include the path and binary name.
   - name: /testbin/true
  
     # An array of input arguments (optional). This should be included if the
     # command needs default arguments.
     input:
       - arg 1
       - arg 2
  
     # An array of expected output lines (optional). This should be specified
     # if the output differs from the default <name>: SUCESS.
     output:
         # The expected output text
       - text: "You should see this message if the test passed!"
         # true if the output is secured, false if not
         trusted:  true
         # true if text references an external command, false* if not
         external: false
  
     # Whether or not the command panics - yes, no*, or maybe
     panics: no
  
     # Whether or not the command is expected to time out - yes, no*, maybe
     timesout: no
  
     # Time (s) after which the test is terminated - 0.0* indicates no timeout
     timeout: 0.0
  ----
  
  Minimally, any command that is to be evaluated for correctness needs to be
  present in exactly one commands (.tc) file with the `name` property specified.
  If no output is specified, the expected output is `<command name>: SUCCESS`.
  
  ==== Examples
  
  In the following example, several tests are specified all of which expect the
  default output.
  
  [source,yaml]
  ----
  templates:
    - name: lt1
    - name: lt2
    - name: sem1
    ...
  ----
  
  Some tests might be designed to cause a kernel panic.
  
  [source,yaml]
  ----
  templates:
    ...
    - name: lt2
      panics: yes
      output:
        - text: "lt2: Should panic..."
    ...
  ----
  
  Some OS/161 tests are composed of other tests, in which case the command output
  will reference an external command:
  
  [source,yaml]
  ----
  templates:
    ...
   - name: /testbin/triplehuge
      output:
        - {text: /testbin/huge, external: true, trusted: true}
        - {text: /testbin/huge, external: true, trusted: true}
        - {text: /testbin/huge, external: true, trusted: true}
    ...
  ----
  
  Input and output can use https://golang.org/pkg/text/template/[Go's text templates]
  to specify more complex text. The arguments and argument length are available in
  the text templates as `.Args` and `.ArgLen`, respectively. Custom functions are
  also provided; see the `funcMap` in
  https://github.com/ops-class/test161/blob/master/commands.go[commands.go]
  for details.
  
  The following example illustrates how the add test's output can be determined
  from random integer inputs:
  
  [source,yaml] 
  ----
  templates:
    ...
    - name: /testbin/add
      input:
        - "{{randInt 2 1000}}"
        - "{{randInt 2 4000}}"
      output:
        - text: "/testbin/add: {{$x:= index .Args 0 | atoi}}{{$y := index .Args 1 | atoi}}{{add $x $y}}"
  ...
  ----
  
  === Tests
  
  Test files (`*.t`) are located in the `tests/` directory in your test161 root
  directory. This directory can contain subdirectories to help organize tests.
  