run-tests: emit exception failure result from Test.run()

run-tests: move test name filter to Test.run()

run-tests: move keyword processing into Test.run()

run-tests: move retesting result to Test.run()

run-tests: move blacklist skipping to Test.run()

run-tests: check for test file existence in Test.run() We delay this a little bit. But it shouldn't really matter when the check is performed.

run-tests: move remaining result processing to Test.run()

run-tests: move output difference processing to Test.run()

run-tests: generate timeout result in Test.run()

run-tests: add skip processing to Test

run-tests: move fail() into Test The code was changed slightly as part of the migration to make use of appropriate variables and modern Python conventions.

run-tests: move success() into Test

run-tests: move err path handling to Test

run-tests: handle interrupted in Test.run()

run-tests: kill daemons during Test.cleanup() As a safety precaution, we kill daemons in Test.cleanup(). This is necessary for a subsequent patch that will reraise KeyboardInterrupt before killdaemons() runs as part of run().

run-tests: capture reference output in Test.__init__ Reference output should be constant and doesn't need to be computed at test execution time. We calculate it earlier. This patch is the first in a mini series that will change how the TestResult object works.

run-tests: make globmatch a static method of TTest

run-tests: make rematch a static method of TTest

run-tests: make linematch a static method of TTest linematch only applies to t tests. It makes sense to move everything t test related to the TTest class.

run-tests: finish moving tsttest() into TTest

run-tests: move t test execution from tsttest() to TTest.run() After this patch, tsttest() only contains output/result processing.

run-tests: move t test parsing into its own function Test parsing is somewhat complicated. This patch extracts it into its own function. The impetus of this patch is folding tsttest() into the TTest class. Subsequent patches will continue this work until tsttest() no longer exists.

run-tests: roll pytest() into PythonTest._run() Python was the old runner function. It no longer needs to exist since the PythonTest class took its job.

run-tests: remove threadtmp in Test.cleanup() threadtmp is an implementation detail. We move the cleanup of this directory to Test.cleanup() and make the variable internal. The cleanup function will eventually disappear into unittest machinery.

run-tests: allow Test.run() to run multiple times Test.run() can now be executed multiple times on the same Test instance. This feature is currently unused and there are no plans to implement it. The main reason for this work was to refactor testtmp, replacements, and env to be run-time specific as opposed to Test instance specific.

run-tests: capture reference output in TestResult class

run-tests: give TestResult a skipped attribute

run-tests: pass TestResult into run()

run-tests: capture execution results in a TestResult class Some implementation details of test execution still live outside of Test. These include determining what a result means and cleaning up after the test. To move to the world where more of this logic can live inside Test or a derived object, the logic for test execution needs to be refactored. Specifically, exception trapping and opportunities for result processing need to be moved into Test. This patch starts the process by establishing a TestResult class for holding the results of a test execution. In order to actually use this class, exception trapping and execution time recording needed to be moved into Test.run().

run-tests: clean up temp directory variables testtmp is an implementation detail. It didn't need to be exposed to the world. threadtmp is derived from count. It is now created as part of the constructor and mostly hidden from the outside world.