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.

run-tests: move env into Test Environment variables are an implementation detail of how tests are executed. This patch moves environment variable logic into Test and completely hides it from the outside. With this patch, a Test can be executed with two lines: init + run(). Tests are still single-use and take a more arguments to the constructor than likely necessary. These will get addressed in subsequent patches.

run-tests: move killdaemons into Test.run() killdaemons() was the only part of runone() looking at env variables. We move killdaemons() into Test.run() to enable us to fully move env into Test.

run-tests: move replacements and port management into Test replacements and ports are really implementation details of a Test. They have been moved to instance variables.

run-tests: move createhgrc() call into Test.run() createhgrc() is an implementation detail of how tests are run. It makes sense to move it into Test.run(). Note that this will cause the test execution time to include the creation of hgrc. The author does not believe this is a significant change worth worrying about.

run-tests: move createenv() into Test createenv() is consulting lots of test-specific variables. It makes sense to attach it to the Test class.

run-tests: move replacements generation into Test The API is a bit funky. Things will look better once all state is captured in Test.

run-tests: move testtmp into Test class This patch starts the process of moving test-specific variables into the Test class. The ultimate goal is to be able to instantiate a Test with minimal arguments and to call run() on it without too much thinking. This will make it much easier to run tests from other contexts. It will also enable things like running a test multiple times.

run-tests: create classes for representing tests Currently, the state for an individual test is scattered across a number of functions and variables. This patch begins a process of isolating a single test's state into instances of a class. It does this by establishing a new Test base class and child classes for Python tests and T tests. The class currently has a run() API that proxies into the existing "runner" functions. Upcoming patches will move the logic for each test type into the class.

revsetbenchmark: add `author(mpm) or author(lmoscovicz)` to the canonical list This matters as `author(mpm)` have a lot of matches evenly split in the repo, while `author(lmoscoviz)` have less match (and later). This changes the execution path of the "or" operator a lot.

filterpyflakes: filter WindowsError unconditionally

filterpyflakes: make memoryview filtering unconditional

py3kcompat: drop unused export

py3kcompat: don't convert os.environ to bytes os.environ accepts str not bytes. Assigning bytes will result in a run-time error.

demandimport: pass proper level to __import__ in Python 3 demandimport was failing in Python 3 with a ValueError because __import__'s level=-1 has gone away (-1 means to try both relative and absolute imports and relative imports don't exist in Python 3). With this patch, demandimport still doesn't work in Python 3 (it fails when importing a non-package module).

help: suggest keyword search when no topic is found When `hg help foobar` fails, it now suggests using `hg help --keyword foobar` instead of printing a full page of basic commands. This should greatly increases discoverability of the `hg help --keyword` argument.