run-tests: allow TestRunner to be passed into main() This allows 3rd parties to specify a custom TestRunner. This is useful for providing your own test discovery mechanism, for example.

run-tests: move test discovery logic into a function The new function is easily monkeypatchable. This facilitates more advanced test discovery by 3rd parties such as extensions.

run-tests: move scheduletests() into TestRunner

run-tests: move abort global to TestRunner

run-tests: move runtests() into TestRunner

run-tests: move results global into TestRunner

run-tests: move times global into TestRunner

run-tests: move gettest() into TestRunner

run-tests: move outputcoverage() into TestRunner

run-tests: move outputtimes() into TestRunner

run-tests: move checkhglib into TestRunner

run-tests: move installhg() into TestRunner

run-tests: move createdfiles out of a global and into TestRunner

run-tests: move usecorrectpython() into TestRunner

run-tests: move cleanup() into TestRunner

run-tests: add options to runner

run-tests: add options to runner

run-tests: move COVERAGE_FILE out of a global

run-tests: move PYTHONDIR out of a global

run-tests: move TMPBINDIR out of a global

run-tests: move BINDIR out of a global

run-tests: move INST out of a global

run-tests: move HGTMP out of a global

run-tests: move TESTDIR out of a global This patch starts the process of removing global variables from run-tests.py. The goal of this is to make it easier to run tests differently without having to concern yourself with global state.

run-tests: establish a class to hold testing state

run-tests: refactor runone() into gettest() and scheduletests() runone() has been removed. Replacing it are gettest() (which returns a Test instance) and a small amount of boilerplate in scheduletests().

run-tests: move computation of test paths into Test.__init__

run-tests: move logging of test start into Test.run()

run-tests: remove remaining uses of TestResult

run-tests: move output writing to Test.run()

run-tests: move err file saving to Test.run()

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.

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.

help: provide a more helpful message when no keyword are matched Before this changeset, when no topic were matching the provided keyword ( in command such as `hg help --keyword babar`) the output was empty. This is confusing and unhelpful for new users seeking assistance in the help. We now display: $ hg help --keyword babar abort: no matches (try "hg help" for a list of topics) This send users in a new direction where they may find what they are looking for.

revsetbenchmark: use optparse to retrieve argument We need more flexibility. For example we'll want to run the benchmark on other repository.

revsetbenchmark: add a usage message when no arguments are passed This increase the odd someone who didn't wrote will it find out how to use this script.

revsetbenchmark: add `::tip and draft()` to the canonical list The want to test element on different side of the iterators.

revset: cosmetic changes in spanset range comparison We use the python syntax for range comparison: `a < x < c`. This is shorter, more readable and less error prone. This comparison escaped the cleanup make in e2031c8ca4f8

revset: drop spanset._contained All its users inlined it for performance reasons. (See 1d7a2771aa36 and e2031c8ca4f8)

patchbomb: includes series information in the header We includes information about the series being patch bombed in all email. Two new headers are added: * X-Mercurial-Series-Index: index of the patches in the series (starts at 1) * X-Mercurial-Series-Total: The total number of patches in the series This information is available in the email subject line, but having them formalized in the header will helps automated tools to process patches send with modern mercurial.

pager: add attend-<command> option This lets users override attend settings locally on a command granularity.

pager: variable reorder

pager: break auto out of command check loop

pager: break always out of command check loop

pager: break pager invocation out of command check loop

tests: fix test failure on vfat It can't handle filenames with spaces. We don't have a good hghave test for this, so we wrap it with unix-permissions.

largefiles: include largefiles when doing log on a directory (issue4241) The matchers _files had to include both the real root and the standin version of the root.

journal: set Abort hint when failing due to an abandoned transaction

merge: define conflict marker labels in filemerge() Moves the conflict marker definition up to filemerge, so it gets applied to all merge strategies, and so in a future patch we can manipulate the markers.

merge: prevent simplemerge from mutating label list simplemerge was using list.pop() to remove items from the labels list. This mutated the list and made it unusable by other calls (for instance, it might be used in both the premerge and actual merge stages).

tests: ignore "undefined name 'memoryview'" pyflakes error on earlier Python Before this patch, "test-check-pyflakes.t" shows unexpected "undefined name 'memoryview'" error for "mercurial/util.py" on Python 2.6.x or earlier, because they don't define symbol 'memoryview'. This patch introduces excluding patterns into "filterpyflakes.py" to ignore "undefined name 'memoryview'" pyflakes error on Python 2.6.x or earlier

mq: eliminate unused variable for test-check-pyflakes.t "user" in "fold()" has become useless since 49148d7868df.

merge: make debug output slightly more helpful by including message for action Make recently introduced messages more useful. Instead of: f1: g f2: m say: f1: remote is newer -> g f2: versions differ -> m

merge: simplify mergestate iter

resolve: simplify "finished" message The recently introduced message was: no unresolved files; you may continue your unfinished operation This had three problems: - looks a bit like an error message because it's not saying "we've just resolved the last file" - refers to "unfinished operation", which won't be the case with "update" or "merge" - introduces semicolons to error messages, which is stylistically questionable I've simplified this to: no more unresolved files In the future, if we want to prompt someone to continue a particular operation, we should use a hint style: no more unresolved files (use 'hg graft --continue' to finish grafting)

resolve: print message when no unresolved files remain (issue4214) When using resolve, users often have to consult with the output of |hg resolve -l| to see if any unresolved files remain. This step is tedious and adds overhead to resolving. This patch will notify a user if there are no unresolved files remaining after executing |hg resolve|:: no unresolved files; you may continue your unfinished operation The patch stops short of telling the user exactly what command should be executed to continue the unfinished operation. That is because this information is not currently captured anywhere. This would make a compelling follow-up feature.

resolve: print warning when no work performed (issue4208) Previously, if the paths specified as arguments to |hg resolve| were invalid, they were silently ignored and a no-op would ensue. This patch fixes that in some scenarios. If none of the paths specified to |hg resolve| match a path that is in mergestate, a warning will be emitted. Ideally, a warning would be emitted for every path/pattern specified that doesn't match anything. To achieve this would require significant refactoring of the matching subsystem. That work is beyond the scope of this patch series. Something is better than nothing and this patch gets us something.

resolve: abort when not applicable (BC) The resolve command is only relevant when mergestate is present. This patch will make resolve abort when no mergestate is present. This change will let people know when they are using resolve when they shouldn't be. This change will let people know when their use of resolve doesn't do anything. Previously, |hg resolve -m| would allow mergestate to be created. This patch now forbids that. Strictly speaking, this is backwards incompatible. The author of this patch believes creating mergestate via resolve doesn't make much sense and this side-effect was unintended.

resolve: split test Part of test-resolve.t is split into multiple tests to create an injection point for new tests that will be added in subsequent patches.

resolve: use early continue and deindent

mergestate: consistently set variables to None Some code branches and exceptional circumstances such as empty mergestate files could result in mergestate._local and mergestate._other not being defined or reset to None. These variables are now correctly set to None when they should be.

changegroup: refactor outgoing logic into a function Extensions that add to bundle2 will want to know which commits are outgoing so they can bundle data that is appropriate to those commits. This moves the logic for figuring that out to a separate function so extensions can do the same computation.

bundle2: fix bundle2 pulling all revs on empty pulls When bundle2 was enabled, if hg pull had no commits to pull, it would print 'no changes found' and then download the entire repository from the server. This was caused by heads and common being set to None, which gets treated as heads=cl.heads() and common=[nullid], which means download the entire repo. Pulling bundles without a changegroup is a valid use case (like if we're just updating bookmarks), so this modifes the bundle code to allow not adding changegroups.

exchange: fix bad indentation Those two lines where double indented for no good reasons.

exchange: propagate arguments to the _getbundleextrapart function The arguments was wrongly propagated (again).

bundle2: fix configuration name mismatch During pulls bundle2 was checking server.bundle2, but during pushes it was checking experimental.bundle2. This makes them both experimental.bundle2.

build: initial support for in-tree autobuilding recipes

tests: declare commands using decorator

share: declare commands using decorator

relink: declare command using decorator

record: declare commands using decorator

hgk: declare commands using decorator

color: declare command using decorator

children: declare command using decorator

fetch: declare command using decorator

extdiff: declare command using decorator

churn: declare command using decorator