I.e. include class name. E.g. Rank.COMMON not COMMON.

Intead of reporting a generic failed test exception, throw a
StudentCodeException that contains the exception thrown by the student's
code. This can then be checked by tester code in case an exception was
expected.

The short message "expected output blah" can confuse students if their
code outputs that line /next/. As in they added an extra line of output
before the expected output.

Warning now specifies when the line was expected.

If the call did not specify the return type, the return type is inferred
from the method. This can give students the impression their code is
returning the right datatype (because the tester is using it) even when
it is not.

A warning has been added to let students know that this may not be the
case.

The method call functions in CodeTester now expect an argument giving
the return type. Can use "null" if you don't care.

The recursive search in the parents should call the recursive method,
not the entry method. By calling the entry method, the original class
was being lost.

Add parameter flag to indicate if a scriptedInteraction should finish
the program. Make the flag default to true.

Also make expectFinished account for remaining output with no end of
line.

Add "expectFinished" method to SubmissionWrapper, use it in the
scriptedInteraction convenience method defined in BaseTester.

Can check static-ness, return type, param types, but not public/private
yet.

You can define if a null return value is considered an error. Useful if
you need to use the returned object later on in the test.

Currently only for constructing "safe" arrays that you want to use as
arguments to student code -- no failure messages provided if
construction fails beyond the normal java reflection exceptions.

Use

    Character[] cs = new Character[] { 'A', 'B', 'C' };
    Object arr = codeTester.constructArray(char.class, cs);
    codeTester.construct("StudentClass", arr);

An example would be if you want a log

    char[] c0 = new char[] { 'A', 'B', 'C' };
    StudentClass sc0 = new StudentClass(c0);

which is better than

    StudentClass sc0 = new StudentClass([c@a82324234);

which it shows if you just passed "new char[] { 'A', 'B', 'C' }".

Add suppressions for deliberate errors or bits where the compiler
doesn't expect reflection.