test: fix hg version check

Signed-off-by: Felipe Contreras <felipe.contreras@gmail.com>

.github/workflows/ci.yml

@@ -1,44 +0,0 @@
-name: CI
-
-# on: [push]
-on:
-  # save cycles; disable on push, enable manual trigger
-  workflow_dispatch:
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        hg: [ '6.0', '6.1', '6.2', '6.3', '6.4', '6.5', '6.6', '6.7', '6.8', '6.9', '7.0' ]
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.11'
-      - uses: actions/cache@v4
-        id: cache-pip
-        with:
-          path: ~/.cache/pip
-          key: pip
-      - name: Install hg
-        run:
-          pip install mercurial==${{ matrix.hg }}
-      - run: prove -j4
-  test-windows:
-    runs-on: windows-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.11'
-      - uses: actions/cache@v4
-        id: cache-pip
-        with:
-          path: ~/appdata/local/pip/cache
-          key: pip-windows
-      - name: Install hg
-        run:
-          pip install mercurial
-      - name: Run all tests
-        run: prove -j4 --exec bash.exe

.gitignore

@@ -1,3 +0,0 @@
-/build/
-/dist/
-/git_remote_hg.egg-info/

.travis.yml

@@ -0,0 +1,26 @@
+language: python
+
+install:
+  - if [ "$HG_VERSION" != "dev" ];
+    then pip install -q Mercurial${HG_VERSION+==$HG_VERSION};
+    else pip install -q http://selenic.com/repo/hg/archive/tip.tar.gz;
+    fi
+  - pip install -q dulwich hg-git || true
+
+before_script:
+  - hg --version || true
+  - pip show hg-git dulwich
+
+script:
+  - export TEST_OPTS='-v'
+  - make test
+
+matrix:
+  include:
+    - env: HG_VERSION=2.9.1
+    - env: HG_VERSION=2.8.2
+    - env: HG_VERSION=2.7.2
+    - env: HG_VERSION=3.0
+    - env: HG_VERSION=dev
+    - python: 2.7
+    - python: 2.6

Makefile

@@ -3,62 +3,27 @@ prefix := $(HOME)
 bindir := $(prefix)/bin
 mandir := $(prefix)/share/man/man1
 
-all: build doc
+all: doc
-
-build:
-	if [ -n "$$PYTHON" ] && "$$PYTHON" -c 'import mercurial' 2> /dev/null ; then \
-		: Use chosen Python version ; \
-	elif python3 -c 'import mercurial' 2> /dev/null ; then \
-		PYTHON=python3 ; \
-	elif python2 -c 'import mercurial' 2> /dev/null ; then \
-		PYTHON=python2 ; \
-	elif python -c 'import mercurial' 2> /dev/null ; then \
-		PYTHON=python ; \
-	else \
-		echo 'Python with Mercurial not available' >&2 ; \
-		exit 1 ; \
-	fi ; \
-	mkdir -p bin ; \
-	for s in git-remote-hg git-hg-helper ; do \
-		printf "%s\n" "#!/usr/bin/env $$PYTHON" > "bin/$$s" ; \
-		tail -n +2 "./$$s" >> "bin/$$s" ; \
-		chmod 755 "bin/$$s" ; \
-		touch -r "./$$s" "bin/$$s" ; \
-	done
 
 doc: doc/git-remote-hg.1
 
 test:
-	$(MAKE) -C t
+	$(MAKE) -C test
 
 doc/git-remote-hg.1: doc/git-remote-hg.txt
-	asciidoctor -d manpage -b manpage $<
+	a2x -d manpage -f manpage $<
 
 clean:
 	$(RM) doc/git-remote-hg.1
-	$(RM) -r bin/
 
 D = $(DESTDIR)
 
-install: build
+install:
 	install -d -m 755 $(D)$(bindir)/
-	install -m 755 bin/git-remote-hg $(D)$(bindir)/git-remote-hg
+	install -m 755 git-remote-hg $(D)$(bindir)/git-remote-hg
-	install -m 755 bin/git-hg-helper $(D)$(bindir)/git-hg-helper
 
 install-doc: doc
 	install -d -m 755 $(D)$(mandir)/
 	install -m 644 doc/git-remote-hg.1 $(D)$(mandir)/git-remote-hg.1
 
-pypi:
+.PHONY: all test install install-doc clean
-	version=`git describe --tags ${REV}` && \
-		sed -i "s/version = .*/version = '$$version'[1:]/" setup.py
-	-rm -rf dist build
-	python setup.py sdist bdist_wheel
-
-pypi-upload:
-	twine upload dist/*
-
-pypi-test:
-	twine upload --repository-url https://test.pypi.org/legacy/ dist/*
-
-.PHONY: all build test install install-doc clean pypy pypy-upload

README.asciidoc

@@ -1,4 +1,4 @@
-`git-remote-hg` is the semi-official Mercurial bridge from the Git project, once
+'git-remote-hg' is the semi-official Mercurial bridge from Git project, once
 installed, it allows you to clone, fetch and push to and from Mercurial
 repositories as if they were Git ones:
 
@@ -6,41 +6,15 @@ repositories as if they were Git ones:
 git clone "hg::http://selenic.com/repo/hello"
 --------------------------------------
 
-To enable this, simply add the `git-remote-hg` script anywhere in your `$PATH`:
+To enable this, simply add the 'git-remote-hg' script anywhere in your `$PATH`:
 
 --------------------------------------
-wget https://raw.githubusercontent.com/mnauw/git-remote-hg/master/git-remote-hg -O ~/bin/git-remote-hg
+wget https://raw.github.com/felipec/git-remote-hg/master/git-remote-hg -O ~/bin/git-remote-hg
 chmod +x ~/bin/git-remote-hg
 --------------------------------------
 
-In Windows, you also need to put and an NTFS symbolic link named `python2.exe` somewhere
-on your `$PATH` pointing to your Python 2 executable:
-
---------------------------------------
-mklink <path to link> <path to python.exe>
---------------------------------------
-
 That's it :)
 
-Obviously you will need Mercurial installed.
-
-****
-At present, this "working copy"/fork <<add-features, adds the following features>>
-(and I would prefer it is indeed rather a "working copy"
-to be appropriately merged upstream):
-
-* eliminates a number of <<limitations, limitations>> as mentioned below
-* properly annotates copy/rename when pushing new commits to Mercurial
-* adds a 'git-hg-helper' script than can aid in the git-hg interaction workflow
-* provides enhanced bidirectional git-hg safety
-* avoids clutter of `refs/hg/...` by keeping these implementation details really private
-* more robust and efficient fetching, especially so when fetching or cloning from multiple
-  Mercurial clones which will only process changesets not yet fetched from elsewhere
-  (as opposed to processing everything all over again)
-
-See sections below or sidemarked notes for more details.
-****
-
 == Configuration ==
 
 If you want to see Mercurial revisions as Git commit notes:
@@ -49,8 +23,7 @@ If you want to see Mercurial revisions as Git commit notes:
 % git config core.notesRef refs/notes/hg
 --------------------------------------
 
-If you are not interested in Mercurial permanent and global branches (aka.
+If you are not interested in Mercurial permanent and global branches (aka. commit labels):
-commit labels):
 
 --------------------------------------
 % git config --global remote-hg.track-branches false
@@ -58,47 +31,29 @@ commit labels):
 
 With this configuration, the 'branches/foo' refs won't appear.
 
-If you want the equivalent of `hg clone --insecure`:
+If you want the equivalent of 'hg clone --insecure':
 
 --------------------------------------
 % git config --global remote-hg.insecure true
 --------------------------------------
 
-If you want `git-remote-hg` to be compatible with `hg-git`, and generate exactly
+If you want 'git-remote-hg' to be compatible with 'hg-git', and generate exactly the same commits:
-the same commits:
 
 --------------------------------------
 % git config --global remote-hg.hg-git-compat true
 --------------------------------------
 
-****
-mnauw's note; The above is not quite the case, it only ever has been (somewhat)
-if an undocumented debug mode (`debugextrainmessage` setting) was enabled
-in (likely somewhat patched) `hg-git`.  And as of `hg-git` v1.2.0 the latter is
-no longer considered.  In fact, `hg-git` creates git commits with additional hg
-metadata stored in so-called "extra commit headers". The latter might be seen by
-`git log --format=raw` or `git cat-file -p <commitid>`, but are otherwise mostly
-only used internally by the git suite (for signatures).  While they are supported
-by `dulwich`'s API (which is a python git implementation), there is, however,
-limited to no support for those in git "porcelain or plumbing" commands. In
-particular, `git fast-export` and `git fast-import` do not consider these, so a
-`gitremote-helpers` tool is then also out of luck.  Incidentally, it also
-follows that a `git fast-export | git fast-import` "clone" approach would also
-lose such extra metadata, and likewise so for e.g. `git filter-repo`.
-
-All in all, this mode is not quite recommended.
-If the concern here is not so much `hg-git` compatibility but rather "hg-git-hg
-round-trip fidelity", then see the discussion below on `check-hg-commits` setting.
-****
-
 == Notes ==
 
-Remember to run `git gc --aggressive` after cloning a repository, especially if
+Remember to run `git gc --aggressive` after cloning a repository, specially if
 it's a big one. Otherwise lots of space will be wasted.
 
+The oldest version of mercurial supported is 1.9. For the most part 1.8 works,
+but you might experience some issues.
+
 === Pushing branches ===
 
-To push a branch, you need to use the 'branches/' prefix:
+To push a branch, you need to use the "branches/" prefix:
 
 --------------------------------------
 % git checkout branches/next
@@ -108,7 +63,7 @@ To push a branch, you need to use the 'branches/' prefix:
 
 All the pushed commits will receive the "next" Mercurial named branch.
 
-*Note*: Make sure you don't have `remote-hg.track-branches` disabled.
+*Note*: Make sure you don't have +remote-hg.track-branches+ disabled.
 
 === Cloning HTTPS ===
 
@@ -118,7 +73,7 @@ The simplest way is to specify the user and password in the URL:
 git clone hg::https://user:password@bitbucket.org/user/repo
 --------------------------------------
 
-You can also use the https://mercurial-scm.org/wiki/SchemesExtension[schemes extension]:
+You can also use the http://mercurial.selenic.com/wiki/SchemesExtension[schemes extension]:
 
 --------------------------------------
 [auth]
@@ -128,24 +83,11 @@ bb.password = password
 --------------------------------------
 
 Finally, you can also use the
-https://pypi.org/project/mercurial_keyring[keyring extension].
+https://pypi.python.org/pypi/mercurial_keyring[keyring extension].
 
-=== Submodules ===
+However, some of these features require very new versions of 'git-remote-hg',
-
+so you might have better luck simply specifying the username and password in
-Hg repositories can be used as git submodule, but this requires to allow the hg procotol to be used by git submodule commands:
+the URL.
-
---------------------------------------
-git config protocol.hg.allow always
---------------------------------------
-
-Or adding manually the following to your git configuration file:
-
---------------------------------------
-[protocol "hg"]
-        allow = always
---------------------------------------
-
-This can be done per-repository, every time after a clone, or globally in the global .gitconfig (using the --global command-line option).
 
 === Caveats ===
 
@@ -156,291 +98,32 @@ Mercurial branches and bookmarks have some limitations of Git branches: you
 can't have both 'dev/feature' and 'dev' (as Git uses files and directories to
 store them).
 
-Multiple anonymous heads (which are useless anyway) are not supported: you
+Multiple anonymous heads (which are useless anyway) are not supported; you
 would only see the latest head.
 
-Closed branches are not supported: they are not shown and you can't close or
+Closed branches are not supported; they are not shown and you can't close or
 reopen. Additionally in certain rare situations a synchronization issue can
 occur (https://github.com/felipec/git/issues/65[Bug #65]).
 
-[[limitations]]
 Limitations of the remote-helpers' framework apply. In particular, these
 commands don't work:
 
 * `git push origin :branch-to-delete`
-
+* `git push origin old:new` (it will push 'old') (patches available)
-****
+* `git push --dry-run origin branch` (it will push) (patches available)
-Another limitation is that if `git log` reports a rename, this will not survive
-the push and Mercurial will not be aware of a rename (and similarly so for copy).
-Though Mercurial would know about it if you *manually* ran `git-format-patch`
-followed by a `hg apply -s`, which is not the nice way to go obviously.
-
-Actually, scratch the limitations above ascribed to the remote-helpers framework.
-They are not limitations of the framework, but are due to how the original
-implementation of 'git-remote-hg' interacts with it.
-Using the remote-helpers framework in only a slightly different way has none
-of the above limitations.  See the <<no-limitations, relevant section>>
-below for more details.
-****
 
 == Other projects ==
 
-There are other `git-remote-hg` projects out there, but this is the original,
+There are other 'git-remote-hg' projects out there, do not confuse this one,
-which was distributed officially in the Git project.
+this is the one distributed officially by the Git project:
 
-Over the years many similar tools have died out, the only actively maintained
+* https://github.com/msysgit/msysgit/wiki/Guide-to-git-remote-hg[msysgit's git-remote-hg]
-alternative is mnauw's fork of this project:
+* https://github.com/rfk/git-remote-hg[rfk's git-remote-hg]
-https://github.com/mnauw/git-remote-hg[mnauw/git-remote-hg]. I've merged some of
-his patches, and he has merged some of my patches, so the projects are mostly in
-sync, but not quite. In particular Nauwelaerts' fork has many administrative
-extensions, which although useful to some people, I don't believe they belong
-in the core.
 
 For a comparison between these and other projects go
 https://github.com/felipec/git/wiki/Comparison-of-git-remote-hg-alternatives[here].
 
-****
-mnauw's note; I do not know what "the core" means?
-However, the "extensions" provide useful and possibly
-critical maintenance wrt git-remote-hg's internal data, so it belongs as close
-to the latter one as possible.
-****
-
-[[no-limitations]]
-== Limitations (or not) ==
-
-If interested in some of technical details behind this explanation, then also
-see the relevant section in 'git-remote-hg' manpage.  Otherwise, the general
-idea is presented here.
-
-More precisely and simply, the <<limitations, mentioned limitations>> are indeed
-limitations of the `export` capability of
-https://www.kernel.org/pub/software/scm/git/docs/gitremote-helpers.html[gitremote-helpers(1)]
-framework.  However, the framework also supports a `push` capability and when this
-is used appropriately in the remote helper the aforementioned limitations do not apply.
-In the case of `export` capability, git-core will internally invoke `git-fast-export`
-and the helper will process this data and hand over generated changesets to Mercurial.
-In the case of `push` capability, git informs the helper what (refs) should go where,
-and the helper is free to ponder about this and take the required action, such as
-to invoke `git-fast-export` itself (with suitable options) and process its output
-the same way as before (and over to Mercurial).
-
-And so;
-
-* `git push origin :branch-to-delete` will delete the bookmark `branch-to-delete` on remote
-* `git push --dry-run origin branch` will not touch the remote
-(or any local state, except for local helper proxy repo)
-* `git push origin old:new` will push `old` onto `new` in the remote
-* `git push origin <history-with-copy/rename>` will push copy/rename aware Mercurial revisions
-
-To tweak how 'git-remote-hg' decides on a copy/rename, use e.g:
---------------------------------------
-% git config --global remote-hg.fast-export-options '-M -C -C'
---------------------------------------
-
-[[add-features]]
-== Additional Features ==
-
-=== Miscellaneous Tweaks ===
-Other than <<no-limitations, removing the limitations>> as mentioned above,
-a number of issues (either so reported in
-https://github.com/felipec/git-remote-hg/issues[issue tracking] or not) have been
-addressed here, e.g. notes handling, `fetch --prune` support, correctly fetching
-after a `strip` on remote repo, tracking remote changes to import (if any) in a
-safe, robust and efficient way, etc.  Some of these have been highlighted above.
-
-For example, the `refs/hg/...` refs are really an implementation detail
-that need not clutter up the (visible) ref space.  So, in as much as they
-are still relevant, these are now kept elsewhere out of sight.
-If somehow your workflow relies on having these in the old place:
---------------------------------------
-% git config --global remote-hg.show-private-refs true
---------------------------------------
-
-More importantly, a significantly more efficient workflow is achieved using
-one set of shared marks files for all remotes (which also forces a local repo
-to use an internal proxy clone).
-The practical consequence is that fetching from a newly added remote hg repo
-does not require another (lengthy) complete import
-(as the original clone) but will only fetch additional changesets (if any).
-The same goes for subsequent fetching from any hg remote; what was fetched
-and imported from some remote need not be imported again from another.
-Operating in this shared mode also has the added advantage
-of correctly pushing after a `strip` on a remote.
-This shared-marks-files behaviour is the default on a fresh repo clone.  It can
-also be enabled on an existing one by the following setting.
---------------------------------------
-% git config --global remote-hg.shared-marks true
---------------------------------------
-Note, however, that one should then perform a fetch from each relevant remote
-to fully complete the conversion (prior to subsequent pushing).
-
-Some Mercurial names (of branches, bookmarks, tags) may not be a valid git
-refname. See e.g. `man git-check-ref-format` for a rather involved set of rules.
-Moreover, while a slash `/` is allowed, it is not supported to have both a `parent`
-and `parent/child` branch (though only the latter is allowed). Even though
-it is not quite (bidirectionally) safe, a (percentage) URL encoding
-(with some additional twist) is performed to obtain sane git refnames, at least
-so for most cases.  If some nasty cases still slip through, then likely only
-a few instances (out of a whole Mercurial repo) are
-problematic.  This could be handled by a single-branch clone and/or configuring
-a suitable refspec.  However, it might be more convenient to simply filter out a
-few unimportant pesky cases, which can be done by configuring a regural
-expression in following setting:
---------------------------------------
-% git config remote-hg.ignore-name nasty/nested/name
---------------------------------------
-Recall also that a config setting can be provided at clone time
-(command line using `--config` option).
-
---------------------------------------
-% git config --global remote-hg.remove-username-quotes false
---------------------------------------
-
-By default, for backwards compatibility with earlier versions,
-git-remote-hg removes quotation marks from git usernames
-(e.g. 'Raffaello "Raphael" Sanzio da Urbino <raphael@example.com>'
-would become 'Raffaello Raphael Sanzio da Urbino
-<raphael@example.com>').  This breaks round-trip compatibility; a git
-commit by an author with quotes would become an hg commit without,
-and if re-imported into git, would get a different SHA1.
-
-To restore round-trip compatibility (at the cost of backwards
-compatibility with commits converted by older versions of
-git-remote-hg), turn 'remote-hg.remove-username-quotes' off.
-
-=== Helper Commands ===
-
-Beyond that, a 'git-hg-helper' script has been added that can aid in the git-hg
-interaction workflow with a number of subcommands that are not in the purview of
-a remote helper.  This is similar to e.g. 'git-svn' being a separate program
-altogether.  These subcommands
-
-* provide conversion from a hg changeset id to a git commit hash, or vice versa
-* provide consistency and cleanup maintenance on internal `git-remote-hg` metadata marks
-* provide optimization of git marks of a fetch-only remote
-
-See the helper script commands' help description for further details.
-It should simply be installed (`$PATH` accessible) next to 'git-remote-hg'.
-Following git alias is probably also convenient as it allows invoking the helper
-as `git hg`:
---------------------------------------
-% git config --global alias.hg '!git-hg-helper'
---------------------------------------
-
-With that in place, running `git hg gc <remote>` after initial fetch from (large)
-<remote> will save quite some space in the git marks file.  Not to mention some time
-each time it is loaded and saved again (upon fetch).  If the remote is ever pushed
-to, the marks file will similarly be squashed, but for a fetch-only <remote>
-the aforementioned command will do.  It may also be needed to run aforementioned
-command after a `git gc` has been performed.  You will notice the need
-when `git-fast-import` or `git-fast-export` complain about not finding objects ;-)
-
-In addition, the helper also provides support routines for `git-remote-hg` that
-provide for increased (or at least safer) git-hg bidirectionality.
-
-Before explaining how it helps, let's first elaborate on what is really
-meant by the above _bidirectionality_ since it can be regarded in 2 directions.
-From the git repo point of view, one can push to a hg repo and then fetch (or
-clone) back to git. Or one could have fetched a changeset from some hg repo and
-then push this back to (another) hg clone.  So what happens in either case? In the
-former case, from git to hg and then back, things work out ok whether or not in
-hg-git compatibility mode.  In the latter case, it is very likely (but
-ultimately not guaranteed) that it works out in hg-git compatibility mode, and far
-less likely otherwise.
-
-Most approaches on bidirectionality try to go for the "mapping" way.
-That is, find a way to map all Mercurial (meta)data somewhere into git;
-in the commit message, or in non-standard ways in extra headers in commit objects
-(e.g. the latest hg-git approach).  The upside of this is that such a git repo can be
-cloned to another git repo, and then one can push back into hg which will/should
-turn out ok.  The downside is setting up such a mapping in the first place,
-avoiding the slightest error in translating authors, timestamps etc,
-and maintaining all that whenever there is some Mercurial API/ABI breakage.
-
-The approach here is to consider a typical git-hg interaction workflow and to
-ensure simple/safe bidirectionality in such a setting.  That is, you are (obviously)
-in a situation having to deal with some Mercurial repo and quite probably
-with various clones as well. The objective is to fetch from these repos/clones,
-work in git and then push back.  And in the latter case, one needs to make sure
-that hg changesets from one hg clone end up *exactly* that way in another hg
-clone (or the git-hg bridge usage might not be so appreciated).  Such pushes are
-probably not recommended workflow practice, but no accidents or issues should
-arise from any push in these circumstances. There is less interest in this setting,
-however, for (git-wise) cloning around the derived git repo.
-
-Now, depending on your workflow and to ensure the above behaves well,
-following setting can be enabled as preferred:
-
---------------------------------------
-% git config --global remote-hg.check-hg-commits fail
-% git config --global remote-hg.check-hg-commits push
---------------------------------------
-
-If not set, the behaviour is as before; pushing a commit based on hg changeset
-will again transform the latter into a new hg changeset which may or may not
-match the original (as described above).
-If set to `fail`, it will reject and abort the push.
-If set to `push`, it will re-use the original changeset in a Mercurial native
-way (rather than creating a new one).  The latter guarantees the changeset ends
-up elsewhere as expected (regardless of conversion mapping or ABI).
-
-Note that identifying and re-using the hg changeset relies on metadata
-(`refs/notes/hg` and marks files) that is not managed or maintained by any
-git-to-git fetch (or clone) (as that is only automatically so for `refs/heads/`,
-though it could be pushed manually).
-As such (and as said), this approach aims for plain-and-simple safety, but only
-within a local scope (git repo).
-
-=== Mercurial Subrepository Support ===
-
-Both Git and Mercurial support a submodule/subrepo system.
-In case of Git, URLs are managed in `.gitmodules`, submodule state is tracked
-in tree objects and only Git submodules are supported.
-Mercurial manages URLs in `.hgsub`, records subrepo state in `.hgsubstate` and
-supports Git, Mercurial and Subversion subrepos (at time of writing).
-Merely the latter diversity in subrepo types shows that somehow mapping Mercurial
-"natively" to git submodules is not quite evident.  Moreover, while one might
-conceivably devise such a mapping restricted to git and hg subrepos, any such would
-seem error-prone and fraught with all sorts of tricky cases and inconvenient
-workflow handling (innovative robust suggestions are welcome though ...)
-
-So, rather than overtaking the plumbing and ending up with stuffed drain further on,
-the approach here is (again) to keep it plain-and-simple.  That is, provide some
-git-ish look-and-feel helper script commands for setting up and manipulating
-subrepos.  And so (if the alias mentioned above has been defined), `git hg sub`
-provides commands similar to `git submodule` that accomplish what is otherwise
-taken care of by the Mercurial subrepo support.
-The latter is obviously extended to be git-aware in that e.g. a Mercurial subrepo
-is cloned as a git-hg subrepo and translation back-and-forth between hg changeset id
-and git commit hash is also performed where needed.  There is no support though
-for Subversion subrepos.
-
-As with the other commands, see the help description for the proper details,
-but the following example session may clarify the principle:
-
---------------------------------------
-% git clone hg::hgparentrepo
-# bring in subrepos in proper location:
-% git hg sub update
-# do some work
-% git pull --rebase origin
-# update subrepo state:
-% git hg sub update
-# do work in subrepo and push
-% ( cd subrepo && git push origin HEAD:master )
-# fetch to update refs/notes/hg (or enable remote-hg.push-updates-notes)
-% ( cd subrepo && git fetch origin )
-# update .hgsubstate to subrepo HEAD:
-% git hg sub upstate
-% git add .hgsubstate
-# add more, commit and push as intended
---------------------------------------
-
-Note that the refspec `HEAD:master` is needed if working with detached `HEAD`
-in subrepo, and that pushing such refspec is actually supported now in a git-hg subrepo
-as explained <<no-limitations, earlier>>.
-
 == Contributing ==
 
-Please file an issue with some patches or a pull-request.
+Send your patches to the mailing list git-fc@googlegroups.com (no need to
+subscribe).

doc/git-remote-hg.txt

@@ -38,8 +38,7 @@ If you want to see Mercurial revisions as Git commit notes:
 % git config core.notesRef refs/notes/hg
 --------------------------------------
 
-If you are not interested in Mercurial permanent and global branches (aka.
+If you are not interested in Mercurial permanent and global branches (aka. commit labels):
-commit labels):
 
 --------------------------------------
 % git config --global remote-hg.track-branches false
@@ -53,83 +52,25 @@ If you want the equivalent of `hg clone --insecure`:
 % git config --global remote-hg.insecure true
 --------------------------------------
 
-If you want 'git-remote-hg' to be compatible with 'hg-git', and generate exactly
+If you want 'git-remote-hg' to be compatible with 'hg-git', and generate exactly the same commits:
-the same commits:
 
 --------------------------------------
 % git config --global remote-hg.hg-git-compat true
 --------------------------------------
 
-If you would like (why?) the old behaviour (export capability)
-where various limitations apply:
-
---------------------------------------
-% git config --global remote-hg.capability-push false
---------------------------------------
-
-In the new behaviour, performing a git push will make git search for and detect
-file rename and copy and turn this into Mercurial commit metadata.  To tweak how this
-detection happens, e.g. have it search even more:
-
---------------------------------------
-% git config --global remote-hg.fast-export-options '-M -C -C'
---------------------------------------
-
-The default otherwise is simply `-M -C`.  See also e.g.
-https://www.kernel.org/pub/software/scm/git/docs/git-log.html[git-log(1) manpage]
-for more details on the options used to tweak this.
-
-As the old refs/hg/... are actually an implementation detail, they are now
-maintained not so visibly.  If that, however, would be preferred:
-
---------------------------------------
-% git config --global remote-hg.show-private-refs true
---------------------------------------
-
-Use of shared marks files is the default in a new repo, but can also be enabled
-for an existing repo:
-
---------------------------------------
-% git config --global remote-hg.shared-marks true
---------------------------------------
-
-Note that one should perform a fetch from each remote to properly complete the
-conversion to shared marks files.
-
-Mercurial name(s) (of a branch or bookmark) that are not a valid git refname,
-can be ignored by configuring a suitable regular expression, e.g. avoiding
-the invalid '~'
-
---------------------------------------
-% git config --global remote-hg.ignore-name ~
---------------------------------------
-
-Even though the "gitdir" is configurable (using `GIT_DIR`), git does not accept
-certain pathname components, e.g. `.git` or `.gitmodules` (case-insensitive).
-Problems arise if the hg repo contains such pathnames, and recent git versions
-will reject this in a very hard way.  So these pathnames are now mapped
-from "hg space" to "git space" in a one-to-one way, where (e.g.)
-`.git[0 or more suffix]` is mapped to `.git[1 or more suffix]` (obviously by
-appending or removing a suffix). The "suffix" in question defaults to `_`,
-but can be configured using
-
---------------------------------------
-% git config --global remote-hg.dotfile-suffix _
---------------------------------------
-
-
 NOTES
 -----
 
-Remember to run `git gc --aggressive` after cloning a repository, especially if
+Remember to run `git gc --aggressive` after cloning a repository, specially if
 it's a big one. Otherwise lots of space will be wasted.
 
-The newest supported version of Mercurial is 6.2, the oldest one is 2.4.
+The oldest version of Mercurial supported is 1.9. For the most part 1.8 works,
+but you might experience some issues.
 
 Pushing branches
 ~~~~~~~~~~~~~~~~
 
-To push a branch, you need to use the "branches/" prefix:
+To push a Mercurial named branch, you need to use the "branches/" prefix:
 
 --------------------------------------
 % git checkout branches/next
@@ -150,7 +91,7 @@ The simplest way is to specify the user and password in the URL:
 git clone hg::https://user:password@bitbucket.org/user/repo
 --------------------------------------
 
-You can also use the https://mercurial-scm.org/wiki/SchemesExtension[schemes extension]:
+You can also use the http://mercurial.selenic.com/wiki/SchemesExtension[schemes extension]:
 
 --------------------------------------
 [auth]
@@ -160,7 +101,7 @@ bb.password = password
 --------------------------------------
 
 Finally, you can also use the
-https://pypi.org/project/mercurial_keyring[keyring extension].
+https://pypi.python.org/pypi/mercurial_keyring[keyring extension].
 
 CAVEATS
 -------
@@ -172,55 +113,9 @@ Mercurial branches and bookmarks have some limitations of Git branches: you
 can't have both 'dev/feature' and 'dev' (as Git uses files and directories to
 store them).
 
-Multiple anonymous heads (which are useless anyway) are not supported: you
+Multiple anonymous heads (which are useless anyway) are not supported; you
 would only see the latest head.
 
-Closed branches are not supported: they are not shown and you can't close or
+Closed branches are not supported; they are not shown and you can't close or
 reopen. Additionally in certain rare situations a synchronization issue can
 occur (https://github.com/felipec/git/issues/65[Bug #65]).
-
-TECHNICAL DISCUSSION
---------------------
-
-As `git-remote-hg` is a developer tool after all, it might be interesting to know a
-bit about what is going on behind the scenes, without necessarily going into all the
-details.
-
-So let's first have a look in the `.git/hg` directory, which typically
-contains a subdirectory for each remote Mercurial repo alias, as well as a `.hg`
-subdirectory.  If the Mercurial repo is a local one, it will (again typically)
-only contain a `marks-git` and a `marks-hg` file.  If the repo is a remote one,
-then the `clone` contains, well, a local clone of the remote.  However, all
-these clones share storage through the `.hg` directory mentioned previously (so
-they do not add up separately). During a fetch/push, the local (proxy) repo is
-used as an intermediate stage. If you would also prefer such an intermediate
-stage for local repos, then setting the environment variable
-`GIT_REMOTE_HG_TEST_REMOTE` will also use a proxy repo clone for a local repo.
-
-As for the marks files, `marks-git` is created and used by `git-fast-export`
-and `git-fast-import` and contains a mapping from mark to commit hash, where a
-mark is essentially a plain number.  `marks-hg` similarly contains a (JSON) based
-mapping between such mark and hg revision hash.  Together they provide for a
-(consistent) view of the synchronization state of things.
-
-When operating with shared-marks files, the `marks-git` and `marks-hg` files
-are shared among all repos.  As such, they are then found in the `.git/hg`
-directory (rather than a repo subdirectory).
-As there is really only one hg repository
-(the shared storage "union bag" in `.git/hg/.hg`), only 1 set of marks files
-should track the mapping between commit hash and revision hash.
-Each individual remote then only adds some metadata (e.g regarding heads).
-
-Upon a fetch, the helper uses the `marks-hg` file to decide what is already present
-and what not.  The required parts are then retrieved from Mercurial and turned
-into a `git-fast-import` stream as expected by `import` capability of
-https://www.kernel.org/pub/software/scm/git/docs/gitremote-helpers.html[gitremote-helpers(1)].
-
-Upon a push, the helper has specified the `push` capability in the new approach, and
-so git will provide a list of refspecs indicating what should go where.
-If the refspecs indicates a remote delete, it is performed appropriately the Mercurial way.
-If it is a regular push, then git-fast-export is invoked (using the existing `marks-git`)
-and the stream is processed and turned into Mercurial commits (along with bookmarks, etc).
-If the refspec specifies a `src:dest` rename, then the requested remote refname is tracked
-accordingly.  If a dry-run is requested, no remote is touched and no (marks) state of
-the run is retained.

setup.py

@@ -1,45 +0,0 @@
-# git-remote-hg setuptools script
-
-import setuptools
-
-# strip leading v
-version = 'v1.0.5'[1:]
-
-# check for released version
-assert (len(version) > 0)
-assert (version.find('-') < 0)
-
-long_description = \
-"""
-'git-remote-hg' is a gitremote protocol helper for Mercurial.
-It allows you to clone, fetch and push to and from Mercurial repositories as if
-they were Git ones using a hg::some-url URL.
-
-See the homepage for much more explanation.
-"""
-
-CLASSIFIERS = [
-    "Programming Language :: Python",
-    "Programming Language :: Python :: 2",
-    "Programming Language :: Python :: 2.7",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.6",
-    "License :: OSI Approved",
-    "License :: OSI Approved :: GNU General Public License v2 (GPLv2)",
-    "Development Status :: 5 - Production/Stable",
-    "Intended Audience :: Developers",
-]
-
-setuptools.setup(name="git-remote-hg",
-      version=version,
-      author="Mark Nauwelaerts",
-      author_email="mnauw@users.sourceforge.net",
-      url="http://github.com/mnauw/git-remote-hg",
-      description="access hg repositories as git remotes",
-      long_description=long_description,
-      license="GPLv2",
-      keywords="git hg mercurial",
-      scripts=["git-remote-hg", "git-hg-helper"],
-      classifiers=CLASSIFIERS
-     )
-

t/expected/converged merge/git-log

@@ -1,60 +0,0 @@
-blob
-mark :1
-data 2
-A
-
-reset refs/heads/master
-commit refs/heads/master
-mark :2
-author A U Thor <author@example.com> 0 +0000
-committer A U Thor <author@example.com> 0 +0000
-data 7
-origin
-M 100644 :1 afile
-
-blob
-mark :3
-data 2
-C
-
-commit refs/heads/master
-mark :4
-author A U Thor <author@example.com> 3 +0000
-committer A U Thor <author@example.com> 3 +0000
-data 5
-A->C
-from :2
-M 100644 :3 afile
-
-blob
-mark :5
-data 2
-B
-
-commit refs/heads/master
-mark :6
-author A U Thor <author@example.com> 1 +0000
-committer A U Thor <author@example.com> 1 +0000
-data 5
-A->B
-from :2
-M 100644 :5 afile
-
-commit refs/heads/master
-mark :7
-author A U Thor <author@example.com> 2 +0000
-committer A U Thor <author@example.com> 2 +0000
-data 5
-B->C
-from :6
-M 100644 :3 afile
-
-commit refs/heads/master
-mark :8
-author A U Thor <author@example.com> 4 +0000
-committer A U Thor <author@example.com> 4 +0000
-data 6
-merge
-from :4
-merge :7
-

t/expected/converged merge/hg-log

@@ -1,67 +0,0 @@
-changeset:   9a6668f453c3003b71e11bb8d7572af57a7ce891
-phase:       draft
-parent:      -0000000000000000000000000000000000000000
-parent:      -0000000000000000000000000000000000000000
-manifest:    331ac2e605f2e6092ccb3802244a65b71f3be726
-user:        A U Thor <author@example.com>
-date:        Thu Jan 01 00:00:00 1970 +0000
-files+:      afile
-extra:       branch=default
-description:
-origin
-
-
-changeset:   ead35d346ecb18ce9d9d54604ff62b41caa196ce
-phase:       draft
-parent:      9a6668f453c3003b71e11bb8d7572af57a7ce891
-parent:      -0000000000000000000000000000000000000000
-manifest:    894f8ad9a84f743d52747963d0b9f4e9cf37d489
-user:        A U Thor <author@example.com>
-date:        Thu Jan 01 00:00:01 1970 +0000
-files:       afile
-extra:       branch=default
-description:
-A->B
-
-
-changeset:   541c7bc8b2d01c8bf71b2298d17edcda120e49bf
-phase:       draft
-parent:      ead35d346ecb18ce9d9d54604ff62b41caa196ce
-parent:      -0000000000000000000000000000000000000000
-manifest:    04dae4001cb1fb2384111589720617c4b742044c
-user:        A U Thor <author@example.com>
-date:        Thu Jan 01 00:00:02 1970 +0000
-files:       afile
-extra:       branch=default
-description:
-B->C
-
-
-changeset:   5694aadcd7171ecb9768b13e29d027e22a360d44
-phase:       draft
-parent:      9a6668f453c3003b71e11bb8d7572af57a7ce891
-parent:      -0000000000000000000000000000000000000000
-manifest:    6efc6bb8e097947aa212887bdb01fb89dfa3de13
-user:        A U Thor <author@example.com>
-date:        Thu Jan 01 00:00:03 1970 +0000
-files:       afile
-extra:       branch=default
-description:
-A->C
-
-
-changeset:   9ee75b4362cc15f9110d6538b2f1c9f0cf14825a
-bookmark:    master
-tag:         tip
-phase:       draft
-parent:      5694aadcd7171ecb9768b13e29d027e22a360d44
-parent:      541c7bc8b2d01c8bf71b2298d17edcda120e49bf
-manifest:    eb9f4687448653e876d787cd6f2e59140680ff09
-user:        A U Thor <author@example.com>
-date:        Thu Jan 01 00:00:04 1970 +0000
-files:       afile
-extra:       branch=default
-description:
-merge
-
-

t/expected/encoding/git-log

@@ -1,56 +0,0 @@
-blob
-mark :1
-data 6
-alpha
-
-reset refs/heads/master
-commit refs/heads/master
-mark :2
-author A U Thor <author@example.com> 1167600600 +0230
-committer C O Mitter <committer@example.com> 1167600600 +0230
-data 12
-add älphà
-M 100644 :1 alpha
-
-blob
-mark :3
-data 5
-beta
-
-commit refs/heads/master
-mark :4
-author tést èncödîng <author@example.com> 1167600600 +0230
-committer C O Mitter <committer@example.com> 1167600600 +0230
-data 9
-add beta
-from :2
-M 100644 :3 beta
-
-blob
-mark :5
-data 6
-gamma
-
-commit refs/heads/master
-mark :6
-author tést èncödîng <author@example.com> 1167600600 +0230
-committer C O Mitter <committer@example.com> 1167600600 +0230
-data 12
-add gämmâ
-from :4
-M 100644 :5 gamma
-
-blob
-mark :7
-data 6
-delta
-
-commit refs/heads/master
-mark :8
-author tést èncödîng <author@example.com> 1167600600 +0230
-committer C O Mitter <committer@example.com> 1167600600 +0230
-data 12
-add déltà
-from :6
-M 100644 :7 delta
-

t/expected/encoding/hg-log

@@ -1,58 +0,0 @@
-changeset:   6674f1c866b5c428db4acde16404c14077889646
-bookmark:    master
-tag:         tip
-phase:       draft
-parent:      7e9fd3fd2f75d7de4bf3d77c47f192a51927ac28
-parent:      -0000000000000000000000000000000000000000
-manifest:    ea49f93388380ead5601c8fcbfa187516e7c2ed8
-user:        tést èncödîng <author@example.com>
-date:        Mon Jan 01 00:00:00 2007 +0230
-files+:      delta
-extra:       branch=default
-extra:       committer=C O Mitter <committer@example.com> 1167600600 -9000
-description:
-add déltà
-
-
-changeset:   7e9fd3fd2f75d7de4bf3d77c47f192a51927ac28
-phase:       draft
-parent:      99c5adad03b9a9935e181f4be91ff7693a790110
-parent:      -0000000000000000000000000000000000000000
-manifest:    f580e7da3673c137370da2b931a1dee83590d7b4
-user:        tést èncödîng <author@example.com>
-date:        Mon Jan 01 00:00:00 2007 +0230
-files+:      gamma
-extra:       branch=default
-extra:       committer=C O Mitter <committer@example.com> 1167600600 -9000
-description:
-add gämmâ
-
-
-changeset:   99c5adad03b9a9935e181f4be91ff7693a790110
-phase:       draft
-parent:      1e3e49d2cc8feaad4942d100108f20f207742d3a
-parent:      -0000000000000000000000000000000000000000
-manifest:    f0bd6fbafbaebe4bb59c35108428f6fce152431d
-user:        tést èncödîng <author@example.com>
-date:        Mon Jan 01 00:00:00 2007 +0230
-files+:      beta
-extra:       branch=default
-extra:       committer=C O Mitter <committer@example.com> 1167600600 -9000
-description:
-add beta
-
-
-changeset:   1e3e49d2cc8feaad4942d100108f20f207742d3a
-phase:       draft
-parent:      -0000000000000000000000000000000000000000
-parent:      -0000000000000000000000000000000000000000
-manifest:    8b8a0e87dfd7a0706c0524afa8ba67e20544cbf0
-user:        A U Thor <author@example.com>
-date:        Mon Jan 01 00:00:00 2007 +0230
-files+:      alpha
-extra:       branch=default
-extra:       committer=C O Mitter <committer@example.com> 1167600600 -9000
-description:
-add älphà
-
-

t/expected/executable bit/log

@@ -1,32 +0,0 @@
-blob
-mark :1
-data 6
-alpha
-
-reset refs/heads/master
-commit refs/heads/master
-mark :2
-author A U Thor <author@example.com> 1167600600 +0230
-committer C O Mitter <committer@example.com> 1167600600 +0230
-data 10
-add alpha
-M 100644 :1 alpha
-
-commit refs/heads/master
-mark :3
-author A U Thor <author@example.com> 1167600600 +0230
-committer C O Mitter <committer@example.com> 1167600600 +0230
-data 19
-set executable bit
-from :2
-M 100755 :1 alpha
-
-commit refs/heads/master
-mark :4
-author A U Thor <author@example.com> 1167600600 +0230
-committer C O Mitter <committer@example.com> 1167600600 +0230
-data 21
-clear executable bit
-from :3
-M 100644 :1 alpha
-

t/expected/executable bit/output

@@ -1,46 +0,0 @@
-changeset:   1efb93106a36bf71352ab04e769a3422522cf946
-bookmark:    master
-tag:         tip
-phase:       draft
-parent:      d7cae8b1fdab97568ba5eca44ca2bf5a44d7c394
-parent:      -0000000000000000000000000000000000000000
-manifest:    51e6255d794f794a8c4e0f03edf264444e3c5ce7
-user:        A U Thor <author@example.com>
-date:        Mon Jan 01 00:00:00 2007 +0230
-files:       alpha
-extra:       branch=default
-extra:       committer=C O Mitter <committer@example.com> 1167600600 -9000
-description:
-clear executable bit
-
-
-changeset:   d7cae8b1fdab97568ba5eca44ca2bf5a44d7c394
-phase:       draft
-parent:      362b656574c3c9e89fa7f2d7a943091dc93bce4d
-parent:      -0000000000000000000000000000000000000000
-manifest:    e4bf4ef5e9aea7a6a57573e533a5519bd062f144
-user:        A U Thor <author@example.com>
-date:        Mon Jan 01 00:00:00 2007 +0230
-files:       alpha
-extra:       branch=default
-extra:       committer=C O Mitter <committer@example.com> 1167600600 -9000
-description:
-set executable bit
-
-
-changeset:   362b656574c3c9e89fa7f2d7a943091dc93bce4d
-phase:       draft
-parent:      -0000000000000000000000000000000000000000
-parent:      -0000000000000000000000000000000000000000
-manifest:    8b8a0e87dfd7a0706c0524afa8ba67e20544cbf0
-user:        A U Thor <author@example.com>
-date:        Mon Jan 01 00:00:00 2007 +0230
-files+:      alpha
-extra:       branch=default
-extra:       committer=C O Mitter <committer@example.com> 1167600600 -9000
-description:
-add alpha
-
-
-644   alpha
-644   alpha

t/expected/file removal/log

@@ -1,60 +0,0 @@
-blob
-mark :1
-data 6
-alpha
-
-reset refs/heads/master
-commit refs/heads/master
-mark :2
-author A U Thor <author@example.com> 1167600600 +0230
-committer C O Mitter <committer@example.com> 1167600600 +0230
-data 10
-add alpha
-M 100644 :1 alpha
-
-blob
-mark :3
-data 5
-beta
-
-commit refs/heads/master
-mark :4
-author A U Thor <author@example.com> 1167600600 +0230
-committer C O Mitter <committer@example.com> 1167600600 +0230
-data 9
-add beta
-from :2
-M 100644 :3 beta
-
-blob
-mark :5
-data 5
-blah
-
-commit refs/heads/master
-mark :6
-author A U Thor <author@example.com> 1167600600 +0230
-committer C O Mitter <committer@example.com> 1167600600 +0230
-data 8
-add foo
-from :4
-M 100644 :5 foo/bar
-
-commit refs/heads/master
-mark :7
-author A U Thor <author@example.com> 1167600600 +0230
-committer C O Mitter <committer@example.com> 1167600600 +0230
-data 13
-remove alpha
-from :6
-D alpha
-
-commit refs/heads/master
-mark :8
-author A U Thor <author@example.com> 1167600600 +0230
-committer C O Mitter <committer@example.com> 1167600600 +0230
-data 15
-remove foo/bar
-from :7
-D foo/bar
-

t/expected/file removal/output

@@ -1,75 +0,0 @@
-changeset:   54f595cbdf1f516dc3b2b25faa6f051aae712f5d
-bookmark:    master
-tag:         tip
-phase:       draft
-parent:      7fe32a9185c6d37db430ee5248cdb2ae66582478
-parent:      -0000000000000000000000000000000000000000
-manifest:    3f83f42fa00fb0cac14a83aa48baac2f287a9329
-user:        A U Thor <author@example.com>
-date:        Mon Jan 01 00:00:00 2007 +0230
-files-:      foo/bar
-extra:       branch=default
-extra:       committer=C O Mitter <committer@example.com> 1167600600 -9000
-description:
-remove foo/bar
-
-
-changeset:   7fe32a9185c6d37db430ee5248cdb2ae66582478
-phase:       draft
-parent:      a21fd0b26a555427c2ea72f8ed37190f6216f705
-parent:      -0000000000000000000000000000000000000000
-manifest:    cd10925837609b99d345c44c85bd1f73d742cbbc
-user:        A U Thor <author@example.com>
-date:        Mon Jan 01 00:00:00 2007 +0230
-files-:      alpha
-extra:       branch=default
-extra:       committer=C O Mitter <committer@example.com> 1167600600 -9000
-description:
-remove alpha
-
-
-changeset:   a21fd0b26a555427c2ea72f8ed37190f6216f705
-phase:       draft
-parent:      7cd99375c843931bd8959b766a94e050f428512b
-parent:      -0000000000000000000000000000000000000000
-manifest:    a6ee442a94bfc6fb0b7d717183bb8b4534ca4ccd
-user:        A U Thor <author@example.com>
-date:        Mon Jan 01 00:00:00 2007 +0230
-files+:      foo/bar
-extra:       branch=default
-extra:       committer=C O Mitter <committer@example.com> 1167600600 -9000
-description:
-add foo
-
-
-changeset:   7cd99375c843931bd8959b766a94e050f428512b
-phase:       draft
-parent:      362b656574c3c9e89fa7f2d7a943091dc93bce4d
-parent:      -0000000000000000000000000000000000000000
-manifest:    f0bd6fbafbaebe4bb59c35108428f6fce152431d
-user:        A U Thor <author@example.com>
-date:        Mon Jan 01 00:00:00 2007 +0230
-files+:      beta
-extra:       branch=default
-extra:       committer=C O Mitter <committer@example.com> 1167600600 -9000
-description:
-add beta
-
-
-changeset:   362b656574c3c9e89fa7f2d7a943091dc93bce4d
-phase:       draft
-parent:      -0000000000000000000000000000000000000000
-parent:      -0000000000000000000000000000000000000000
-manifest:    8b8a0e87dfd7a0706c0524afa8ba67e20544cbf0
-user:        A U Thor <author@example.com>
-date:        Mon Jan 01 00:00:00 2007 +0230
-files+:      alpha
-extra:       branch=default
-extra:       committer=C O Mitter <committer@example.com> 1167600600 -9000
-description:
-add alpha
-
-
-beta
-foo/bar
-beta

t/expected/git tags/log

@@ -1,32 +0,0 @@
-changeset:   7cd99375c843931bd8959b766a94e050f428512b
-bookmark:    master
-tag:         beta
-tag:         tip
-phase:       draft
-parent:      362b656574c3c9e89fa7f2d7a943091dc93bce4d
-parent:      -0000000000000000000000000000000000000000
-manifest:    f0bd6fbafbaebe4bb59c35108428f6fce152431d
-user:        A U Thor <author@example.com>
-date:        Mon Jan 01 00:00:00 2007 +0230
-files+:      beta
-extra:       branch=default
-extra:       committer=C O Mitter <committer@example.com> 1167600600 -9000
-description:
-add beta
-
-
-changeset:   362b656574c3c9e89fa7f2d7a943091dc93bce4d
-tag:         alpha
-phase:       draft
-parent:      -0000000000000000000000000000000000000000
-parent:      -0000000000000000000000000000000000000000
-manifest:    8b8a0e87dfd7a0706c0524afa8ba67e20544cbf0
-user:        A U Thor <author@example.com>
-date:        Mon Jan 01 00:00:00 2007 +0230
-files+:      alpha
-extra:       branch=default
-extra:       committer=C O Mitter <committer@example.com> 1167600600 -9000
-description:
-add alpha
-
-

t/expected/hg author/git-log

@@ -1,141 +0,0 @@
-blob
-mark :1
-data 6
-alpha
-
-reset refs/heads/not-master
-commit refs/heads/not-master
-mark :2
-author A U Thor <author@example.com> 1167600600 +0230
-committer C O Mitter <committer@example.com> 1167600600 +0230
-data 10
-add alpha
-M 100644 :1 alpha
-
-blob
-mark :3
-data 5
-beta
-
-commit refs/heads/master
-mark :4
-author test <none@none> 0 +0000
-committer test <none@none> 0 +0000
-data 9
-add beta
-from :2
-M 100644 :3 beta
-
-blob
-mark :5
-data 11
-beta
-gamma
-
-commit refs/heads/master
-mark :6
-author test ext:(%20%28comment%29) <test@example.com> 0 +0000
-committer test ext:(%20%28comment%29) <test@example.com> 0 +0000
-data 12
-modify beta
-from :4
-M 100644 :5 beta
-
-blob
-mark :7
-data 6
-gamma
-
-commit refs/heads/master
-mark :8
-author  <test@example.com> 0 +0000
-committer  <test@example.com> 0 +0000
-data 10
-add gamma
-from :6
-M 100644 :7 gamma
-
-blob
-mark :9
-data 6
-delta
-
-commit refs/heads/master
-mark :10
-author name <test@example.com> 0 +0000
-committer name <test@example.com> 0 +0000
-data 10
-add delta
-from :8
-M 100644 :9 delta
-
-blob
-mark :11
-data 8
-epsilon
-
-commit refs/heads/master
-mark :12
-author name <test@example.com> 0 +0000
-committer name <test@example.com> 0 +0000
-data 12
-add epsilon
-from :10
-M 100644 :11 epsilon
-
-blob
-mark :13
-data 5
-zeta
-
-commit refs/heads/master
-mark :14
-author test <none@none> 0 +0000
-committer test <none@none> 0 +0000
-data 9
-add zeta
-from :12
-M 100644 :13 zeta
-
-blob
-mark :15
-data 4
-eta
-
-commit refs/heads/master
-mark :16
-author test <test@example.com> 0 +0000
-committer test <test@example.com> 0 +0000
-data 8
-add eta
-from :14
-M 100644 :15 eta
-
-blob
-mark :17
-data 6
-theta
-
-commit refs/heads/master
-mark :18
-author test ?test@example.com <test ?test@example.com> 0 +0000
-committer test ?test@example.com <test ?test@example.com> 0 +0000
-data 10
-add theta
-from :16
-M 100644 :17 theta
-
-blob
-mark :19
-data 5
-iota
-
-commit refs/heads/master
-mark :20
-author test ext:(%20example%20%3Cdot%3E%20com%3E) <test ?at> 0 +0000
-committer test ext:(%20example%20%3Cdot%3E%20com%3E) <test ?at> 0 +0000
-data 9
-add iota
-from :18
-M 100644 :19 iota
-

t/expected/hg author/hg-log

@@ -1,134 +0,0 @@
-changeset:   307c03466a07cccafaafc991f36d695d6ad595f3
-bookmark:    master
-tag:         tip
-phase:       draft
-parent:      5832614d351449a2f8d6f7ccbef4877c2b18cbe0
-parent:      -0000000000000000000000000000000000000000
-manifest:    e8f1b3ae088bdd25e3570a4953ccb6b948524473
-user:        test <test ?at> example <dot> com>
-date:        Thu Jan 01 00:00:00 1970 +0000
-files+:      iota
-extra:       branch=default
-description:
-add iota
-
-
-changeset:   5832614d351449a2f8d6f7ccbef4877c2b18cbe0
-phase:       draft
-parent:      e52ded4aca5d210ed58c63158d64fb911876f345
-parent:      -0000000000000000000000000000000000000000
-manifest:    7e4875db7e2970c529f462520121d333e514bf4d
-user:        test ?test@example.com <test ?test@example.com>
-date:        Thu Jan 01 00:00:00 1970 +0000
-files+:      theta
-extra:       branch=default
-description:
-add theta
-
-
-changeset:   e52ded4aca5d210ed58c63158d64fb911876f345
-phase:       draft
-parent:      9a34ba7d552e8b73ad306baf1d1eb83de0f74c12
-parent:      -0000000000000000000000000000000000000000
-manifest:    ef03e54a9916ac3158c9686503dd4f609c26b3ec
-user:        test <test@example.com>
-date:        Thu Jan 01 00:00:00 1970 +0000
-files+:      eta
-extra:       branch=default
-description:
-add eta
-
-
-changeset:   9a34ba7d552e8b73ad306baf1d1eb83de0f74c12
-phase:       draft
-parent:      6281edc25b9fe9538407726f044a9a61ac7ba5bc
-parent:      -0000000000000000000000000000000000000000
-manifest:    616201b85baf7ed02d41f6a7deb04c52009d8483
-user:        test
-date:        Thu Jan 01 00:00:00 1970 +0000
-files+:      zeta
-extra:       branch=default
-description:
-add zeta
-
-
-changeset:   6281edc25b9fe9538407726f044a9a61ac7ba5bc
-phase:       draft
-parent:      4c7841053c633cb51f8375555d08b6bea54fc4cb
-parent:      -0000000000000000000000000000000000000000
-manifest:    c703b3d7be8a0638047142f57ff83d4e94b5d1fa
-user:        name <test@example.com>
-date:        Thu Jan 01 00:00:00 1970 +0000
-files+:      epsilon
-extra:       branch=default
-description:
-add epsilon
-
-
-changeset:   4c7841053c633cb51f8375555d08b6bea54fc4cb
-phase:       draft
-parent:      fa8f26586397dd4797842e9300c8db221fe5514d
-parent:      -0000000000000000000000000000000000000000
-manifest:    300b54001cbfa5d027b4bccdb594ccb463adb55d
-user:        name <test@example.com>
-date:        Thu Jan 01 00:00:00 1970 +0000
-files+:      delta
-extra:       branch=default
-description:
-add delta
-
-
-changeset:   fa8f26586397dd4797842e9300c8db221fe5514d
-phase:       draft
-parent:      2708ff417fb7e2c0a4f9596286c0a398553fa793
-parent:      -0000000000000000000000000000000000000000
-manifest:    45b0c483a79307d14f7e234feb78776478f828ec
-user:        <test@example.com>
-date:        Thu Jan 01 00:00:00 1970 +0000
-files+:      gamma
-extra:       branch=default
-description:
-add gamma
-
-
-changeset:   2708ff417fb7e2c0a4f9596286c0a398553fa793
-phase:       draft
-parent:      8c51e5fe974fe1cc63a56bbfad343f9ede6bed30
-parent:      -0000000000000000000000000000000000000000
-manifest:    c305998040b12e956b998318982c9eb92d2d7b28
-user:        test <test@example.com> (comment)
-date:        Thu Jan 01 00:00:00 1970 +0000
-files:       beta
-extra:       branch=default
-description:
-modify beta
-
-
-changeset:   8c51e5fe974fe1cc63a56bbfad343f9ede6bed30
-phase:       draft
-parent:      362b656574c3c9e89fa7f2d7a943091dc93bce4d
-parent:      -0000000000000000000000000000000000000000
-manifest:    f0bd6fbafbaebe4bb59c35108428f6fce152431d
-user:        test
-date:        Thu Jan 01 00:00:00 1970 +0000
-files+:      beta
-extra:       branch=default
-description:
-add beta
-
-
-changeset:   362b656574c3c9e89fa7f2d7a943091dc93bce4d
-bookmark:    not-master
-phase:       draft
-parent:      -0000000000000000000000000000000000000000
-parent:      -0000000000000000000000000000000000000000
-manifest:    8b8a0e87dfd7a0706c0524afa8ba67e20544cbf0
-user:        A U Thor <author@example.com>
-date:        Mon Jan 01 00:00:00 2007 +0230
-files+:      alpha
-extra:       branch=default
-extra:       committer=C O Mitter <committer@example.com> 1167600600 -9000
-description:
-add alpha
-
-

t/expected/hg branch/git-log

@@ -1,38 +0,0 @@
-blob
-mark :1
-data 6
-alpha
-
-reset refs/heads/not-master
-commit refs/heads/not-master
-mark :2
-author A U Thor <author@example.com> 1167600600 +0230
-committer C O Mitter <committer@example.com> 1167600600 +0230
-data 10
-add alpha
-M 100644 :1 alpha
-
-commit refs/heads/master
-mark :3
-author A U Thor <author@example.com> 0 +0000
-committer A U Thor <author@example.com> 0 +0000
-data 52
-rename alpha to beta
-
---HG--
-rename : alpha => beta
-from :2
-D alpha
-M 100644 :1 beta
-
-commit refs/heads/master
-mark :4
-author A U Thor <author@example.com> 0 +0000
-committer A U Thor <author@example.com> 0 +0000
-data 44
-started branch gamma
-
---HG--
-branch : gamma
-from :3
-

t/expected/hg branch/hg-log

@@ -1,44 +0,0 @@
-changeset:   3320583a8de0b31511f499a4ab3426bee1a7f478
-branch:      gamma
-bookmark:    master
-tag:         tip
-phase:       draft
-parent:      5889597089fea2d144989baa9427d1a080293fdb
-parent:      -0000000000000000000000000000000000000000
-manifest:    e353b4d5282d044ad738398fd32d0b684d04a14b
-user:        A U Thor <author@example.com>
-date:        Thu Jan 01 00:00:00 1970 +0000
-extra:       branch=gamma
-description:
-started branch gamma
-
-
-changeset:   5889597089fea2d144989baa9427d1a080293fdb
-phase:       draft
-parent:      362b656574c3c9e89fa7f2d7a943091dc93bce4d
-parent:      -0000000000000000000000000000000000000000
-manifest:    e353b4d5282d044ad738398fd32d0b684d04a14b
-user:        A U Thor <author@example.com>
-date:        Thu Jan 01 00:00:00 1970 +0000
-files+:      beta
-files-:      alpha
-extra:       branch=default
-description:
-rename alpha to beta
-
-
-changeset:   362b656574c3c9e89fa7f2d7a943091dc93bce4d
-bookmark:    not-master
-phase:       draft
-parent:      -0000000000000000000000000000000000000000
-parent:      -0000000000000000000000000000000000000000
-manifest:    8b8a0e87dfd7a0706c0524afa8ba67e20544cbf0
-user:        A U Thor <author@example.com>
-date:        Mon Jan 01 00:00:00 2007 +0230
-files+:      alpha
-extra:       branch=default
-extra:       committer=C O Mitter <committer@example.com> 1167600600 -9000
-description:
-add alpha
-
-

t/expected/hg tags/output

@@ -1,33 +0,0 @@
-alpha
-changeset:   16869bbe54be9f8082a8aec346de09f6c05cf1de
-bookmark:    master
-tag:         tip
-phase:       draft
-parent:      362b656574c3c9e89fa7f2d7a943091dc93bce4d
-parent:      -0000000000000000000000000000000000000000
-manifest:    26f8145fb5b20cc6f70dd131b646f95ab79738c0
-user:        A U Thor <author@example.com>
-date:        Thu Jan 01 00:00:00 1970 +0000
-files+:      .hgtags
-extra:       branch=default
-description:
-Added tag alpha for changeset 362b656574c3
-
-
-changeset:   362b656574c3c9e89fa7f2d7a943091dc93bce4d
-bookmark:    not-master
-tag:         alpha
-phase:       draft
-parent:      -0000000000000000000000000000000000000000
-parent:      -0000000000000000000000000000000000000000
-manifest:    8b8a0e87dfd7a0706c0524afa8ba67e20544cbf0
-user:        A U Thor <author@example.com>
-date:        Mon Jan 01 00:00:00 2007 +0230
-files+:      alpha
-extra:       branch=default
-extra:       committer=C O Mitter <committer@example.com> 1167600600 -9000
-description:
-add alpha
-
-
-362b656574c3c9e89fa7f2d7a943091dc93bce4d alpha

t/expected/merge conflict 1/git-log

@@ -1,51 +0,0 @@
-blob
-mark :1
-data 2
-A
-
-reset refs/heads/master
-commit refs/heads/master
-mark :2
-author A U Thor <author@example.com> 0 +0000
-committer A U Thor <author@example.com> 0 +0000
-data 7
-origin
-M 100644 :1 afile
-
-blob
-mark :3
-data 2
-C
-
-commit refs/heads/master
-mark :4
-author A U Thor <author@example.com> 2 +0000
-committer A U Thor <author@example.com> 2 +0000
-data 5
-A->C
-from :2
-M 100644 :3 afile
-
-blob
-mark :5
-data 2
-B
-
-commit refs/heads/master
-mark :6
-author A U Thor <author@example.com> 1 +0000
-committer A U Thor <author@example.com> 1 +0000
-data 5
-A->B
-from :2
-M 100644 :5 afile
-
-commit refs/heads/master
-mark :7
-author A U Thor <author@example.com> 3 +0000
-committer A U Thor <author@example.com> 3 +0000
-data 11
-merge to C
-from :4
-merge :6
-

t/expected/merge conflict 1/hg-log

@@ -1,54 +0,0 @@
-changeset:   9a6668f453c3003b71e11bb8d7572af57a7ce891
-phase:       draft
-parent:      -0000000000000000000000000000000000000000
-parent:      -0000000000000000000000000000000000000000
-manifest:    331ac2e605f2e6092ccb3802244a65b71f3be726
-user:        A U Thor <author@example.com>
-date:        Thu Jan 01 00:00:00 1970 +0000
-files+:      afile
-extra:       branch=default
-description:
-origin
-
-
-changeset:   ead35d346ecb18ce9d9d54604ff62b41caa196ce
-phase:       draft
-parent:      9a6668f453c3003b71e11bb8d7572af57a7ce891
-parent:      -0000000000000000000000000000000000000000
-manifest:    894f8ad9a84f743d52747963d0b9f4e9cf37d489
-user:        A U Thor <author@example.com>
-date:        Thu Jan 01 00:00:01 1970 +0000
-files:       afile
-extra:       branch=default
-description:
-A->B
-
-
-changeset:   d585ac55494928500f510b965b878d47f9ee60f6
-phase:       draft
-parent:      9a6668f453c3003b71e11bb8d7572af57a7ce891
-parent:      -0000000000000000000000000000000000000000
-manifest:    6efc6bb8e097947aa212887bdb01fb89dfa3de13
-user:        A U Thor <author@example.com>
-date:        Thu Jan 01 00:00:02 1970 +0000
-files:       afile
-extra:       branch=default
-description:
-A->C
-
-
-changeset:   c6ab734e24c39948e5a25713b48f4972c960ff8b
-bookmark:    master
-tag:         tip
-phase:       draft
-parent:      d585ac55494928500f510b965b878d47f9ee60f6
-parent:      ead35d346ecb18ce9d9d54604ff62b41caa196ce
-manifest:    96bedb13781f1b9d729a2210a530f0c5c68f42e6
-user:        A U Thor <author@example.com>
-date:        Thu Jan 01 00:00:03 1970 +0000
-files:       afile
-extra:       branch=default
-description:
-merge to C
-
-

t/expected/merge conflict 2/git-log

@@ -1,52 +0,0 @@
-blob
-mark :1
-data 2
-A
-
-reset refs/heads/master
-commit refs/heads/master
-mark :2
-author A U Thor <author@example.com> 0 +0000
-committer A U Thor <author@example.com> 0 +0000
-data 7
-origin
-M 100644 :1 afile
-
-blob
-mark :3
-data 2
-C
-
-commit refs/heads/master
-mark :4
-author A U Thor <author@example.com> 2 +0000
-committer A U Thor <author@example.com> 2 +0000
-data 5
-A->C
-from :2
-M 100644 :3 afile
-
-blob
-mark :5
-data 2
-B
-
-commit refs/heads/master
-mark :6
-author A U Thor <author@example.com> 1 +0000
-committer A U Thor <author@example.com> 1 +0000
-data 5
-A->B
-from :2
-M 100644 :5 afile
-
-commit refs/heads/master
-mark :7
-author A U Thor <author@example.com> 3 +0000
-committer A U Thor <author@example.com> 3 +0000
-data 11
-merge to B
-from :4
-merge :6
-M 100644 :5 afile
-

t/expected/merge conflict 2/hg-log

@@ -1,54 +0,0 @@
-changeset:   9a6668f453c3003b71e11bb8d7572af57a7ce891
-phase:       draft
-parent:      -0000000000000000000000000000000000000000
-parent:      -0000000000000000000000000000000000000000
-manifest:    331ac2e605f2e6092ccb3802244a65b71f3be726
-user:        A U Thor <author@example.com>
-date:        Thu Jan 01 00:00:00 1970 +0000
-files+:      afile
-extra:       branch=default
-description:
-origin
-
-
-changeset:   ead35d346ecb18ce9d9d54604ff62b41caa196ce
-phase:       draft
-parent:      9a6668f453c3003b71e11bb8d7572af57a7ce891
-parent:      -0000000000000000000000000000000000000000
-manifest:    894f8ad9a84f743d52747963d0b9f4e9cf37d489
-user:        A U Thor <author@example.com>
-date:        Thu Jan 01 00:00:01 1970 +0000
-files:       afile
-extra:       branch=default
-description:
-A->B
-
-
-changeset:   d585ac55494928500f510b965b878d47f9ee60f6
-phase:       draft
-parent:      9a6668f453c3003b71e11bb8d7572af57a7ce891
-parent:      -0000000000000000000000000000000000000000
-manifest:    6efc6bb8e097947aa212887bdb01fb89dfa3de13
-user:        A U Thor <author@example.com>
-date:        Thu Jan 01 00:00:02 1970 +0000
-files:       afile
-extra:       branch=default
-description:
-A->C
-
-
-changeset:   542b187b70e70dc759631d1065794f3c2c5a3e7b
-bookmark:    master
-tag:         tip
-phase:       draft
-parent:      d585ac55494928500f510b965b878d47f9ee60f6
-parent:      ead35d346ecb18ce9d9d54604ff62b41caa196ce
-manifest:    0907d7dbc98790102fa6cb91b68b271ef0bc5b64
-user:        A U Thor <author@example.com>
-date:        Thu Jan 01 00:00:03 1970 +0000
-files:       afile
-extra:       branch=default
-description:
-merge to B
-
-

t/expected/rename/git-log

@@ -1,27 +0,0 @@
-blob
-mark :1
-data 6
-alpha
-
-reset refs/heads/master
-commit refs/heads/master
-mark :2
-author A U Thor <author@example.com> 0 +0000
-committer A U Thor <author@example.com> 0 +0000
-data 10
-add alpha
-M 100644 :1 alpha
-
-commit refs/heads/master
-mark :3
-author A U Thor <author@example.com> 0 +0000
-committer A U Thor <author@example.com> 0 +0000
-data 52
-rename alpha to beta
-
---HG--
-rename : alpha => beta
-from :2
-D alpha
-M 100644 :1 beta
-

t/expected/rename/hg-log

@@ -1,29 +0,0 @@
-changeset:   a985b184598fd779e53576c65c5dd1d274736c73
-bookmark:    master
-tag:         tip
-phase:       draft
-parent:      0558a161e3ca0d59f5f165e3182402d9f1e574a8
-parent:      -0000000000000000000000000000000000000000
-manifest:    e353b4d5282d044ad738398fd32d0b684d04a14b
-user:        A U Thor <author@example.com>
-date:        Thu Jan 01 00:00:00 1970 +0000
-files+:      beta
-files-:      alpha
-extra:       branch=default
-description:
-rename alpha to beta
-
-
-changeset:   0558a161e3ca0d59f5f165e3182402d9f1e574a8
-phase:       draft
-parent:      -0000000000000000000000000000000000000000
-parent:      -0000000000000000000000000000000000000000
-manifest:    8b8a0e87dfd7a0706c0524afa8ba67e20544cbf0
-user:        A U Thor <author@example.com>
-date:        Thu Jan 01 00:00:00 1970 +0000
-files+:      alpha
-extra:       branch=default
-description:
-add alpha
-
-

t/expected/symlink/log

@@ -1,27 +0,0 @@
-blob
-mark :1
-data 6
-alpha
-
-reset refs/heads/master
-commit refs/heads/master
-mark :2
-author A U Thor <author@example.com> 1167600600 +0230
-committer C O Mitter <committer@example.com> 1167600600 +0230
-data 10
-add alpha
-M 100644 :1 alpha
-
-blob
-mark :3
-data 5
-alpha
-commit refs/heads/master
-mark :4
-author A U Thor <author@example.com> 1167600600 +0230
-committer C O Mitter <committer@example.com> 1167600600 +0230
-data 9
-add beta
-from :2
-M 120000 :3 beta
-

t/expected/symlink/output

@@ -1,32 +0,0 @@
-changeset:   87cbc97576079d3dfef04c678bfc8ab69999ebdf
-bookmark:    master
-tag:         tip
-phase:       draft
-parent:      362b656574c3c9e89fa7f2d7a943091dc93bce4d
-parent:      -0000000000000000000000000000000000000000
-manifest:    4950f48a7f5b0ce6f31c2f4307e296dbac652026
-user:        A U Thor <author@example.com>
-date:        Mon Jan 01 00:00:00 2007 +0230
-files+:      beta
-extra:       branch=default
-extra:       committer=C O Mitter <committer@example.com> 1167600600 -9000
-description:
-add beta
-
-
-changeset:   362b656574c3c9e89fa7f2d7a943091dc93bce4d
-phase:       draft
-parent:      -0000000000000000000000000000000000000000
-parent:      -0000000000000000000000000000000000000000
-manifest:    8b8a0e87dfd7a0706c0524afa8ba67e20544cbf0
-user:        A U Thor <author@example.com>
-date:        Mon Jan 01 00:00:00 2007 +0230
-files+:      alpha
-extra:       branch=default
-extra:       committer=C O Mitter <committer@example.com> 1167600600 -9000
-description:
-add alpha
-
-
-644   alpha
-644 @ beta

t/helper.t

@@ -1,542 +0,0 @@
-#!/bin/bash
-#
-# Copyright (c) 2016 Mark Nauwelaerts
-#
-# Base commands from hg-git tests:
-# https://bitbucket.org/durin42/hg-git/src
-#
-
-test_description='Test git-hg-helper'
-
-. "$(dirname "$0")"/test-lib.sh
-
-if ! test_have_prereq PYTHON
-then
-	skip_all='skipping remote-hg tests; python with mercurial not available'
-	test_done
-fi
-
-setup () {
-	cat > "$HOME"/.hgrc <<-EOF &&
-	[ui]
-	username = H G Wells <wells@example.com>
-	[extensions]
-	mq =
-	strip =
-	[subrepos]
-	git:allowed = true
-	EOF
-
-	GIT_AUTHOR_DATE="2007-01-01 00:00:00 +0230" &&
-	GIT_COMMITTER_DATE="$GIT_AUTHOR_DATE" &&
-	export GIT_COMMITTER_DATE GIT_AUTHOR_DATE
-}
-
-setup
-
-setup_repos () {
-	(
-	hg init hgrepo &&
-	cd hgrepo &&
-	echo zero > content &&
-	hg add content &&
-	hg commit -m zero
-	) &&
-
-	git clone hg::hgrepo gitrepo
-}
-
-test_expect_success 'subcommand help' '
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	setup_repos &&
-
-	(
-	cd gitrepo &&
-	test_expect_code 2 git-hg-helper help 2> ../help
-	)
-	# remotes should be in help output
-	grep origin help
-'
-
-git config --global remote-hg.shared-marks false
-test_expect_success 'subcommand repo - no local proxy' '
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	setup_repos &&
-
-	(
-	cd hgrepo &&
-	pwd >../expected
-	) &&
-
-	(
-	cd gitrepo &&
-	git-hg-helper repo origin > ../actual
-	) &&
-
-	test_cmp expected actual
-'
-
-git config --global --unset remote-hg.shared-marks
-
-GIT_REMOTE_HG_TEST_REMOTE=1 &&
-export GIT_REMOTE_HG_TEST_REMOTE
-
-test_expect_success 'subcommand repo - with local proxy' '
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	setup_repos &&
-
-	(
-	cd gitrepo &&
-	export gitdir=`git rev-parse --git-dir`
-	# trick to normalize path
-	( cd $gitdir/hg/origin/clone && pwd ) >../expected &&
-	( cd `git-hg-helper repo origin` && pwd ) > ../actual
-	) &&
-
-	test_cmp expected actual
-'
-
-test_expect_success 'subcommands hg-rev and git-rev and mapfile' '
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	setup_repos &&
-
-	(
-	cd gitrepo &&
-	git rev-parse HEAD > rev-HEAD &&
-	test -s rev-HEAD &&
-	git-hg-helper hg-rev `cat rev-HEAD` > hg-HEAD &&
-	git-hg-helper git-rev `cat hg-HEAD` > git-HEAD &&
-	git-hg-helper mapfile --output mapfile origin &&
-	test_cmp rev-HEAD git-HEAD &&
-	grep "`cat rev-HEAD` `cat hg-HEAD`" mapfile
-	)
-'
-
-test_expect_success 'subcommand gc' '
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	(
-	hg init hgrepo &&
-	cd hgrepo &&
-	echo zero > content &&
-	hg add content &&
-	hg commit -m zero
-	echo one > content &&
-	hg commit -m one &&
-	echo two > content &&
-	hg commit -m two &&
-	echo three > content &&
-	hg commit -m three
-	) &&
-
-	git clone hg::hgrepo gitrepo &&
-
-	(
-	cd hgrepo &&
-	hg strip -r 1 &&
-	echo four > content &&
-	hg commit -m four
-	) &&
-
-	(
-	cd gitrepo &&
-	git fetch origin &&
-	git reset --hard origin/master &&
-	git gc &&
-	git-hg-helper gc --check-hg origin > output &&
-	cat output &&
-	grep "hg marks" output &&
-	grep "git marks" output
-	)
-'
-
-test_expect_success 'subcommand [some-repo]' '
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	setup_repos &&
-
-	(
-	cd hgrepo &&
-	echo one > content &&
-	hg commit -m one
-	) &&
-
-	(
-	cd gitrepo &&
-	git fetch origin
-	) &&
-
-	hg log -R hgrepo > expected &&
-	# not inside gitrepo; test shared path handling
-	GIT_DIR=gitrepo/.git git-hg-helper origin log > actual
-
-	test_cmp expected actual
-'
-
-setup_repo () {
-    kind=$1 &&
-    repo=$2 &&
-    $kind init $repo &&
-    (
-    cd $repo &&
-    echo zero > content_$repo &&
-    $kind add content_$repo &&
-    $kind commit -m zero_$repo
-    )
-}
-
-check () {
-	echo $3 > expected &&
-	git --git-dir=$1/.git log --format='%s' -1 $2 > actual &&
-	test_cmp expected actual
-}
-
-check_branch () {
-	if test -n "$3"
-	then
-		echo $3 > expected &&
-		hg -R $1 log -r $2 --template '{desc}\n' > actual &&
-		test_cmp expected actual
-	else
-		hg -R $1 branches > out &&
-		! grep $2 out
-	fi
-}
-
-test_expect_success 'subcommand sub initial update (hg and git subrepos)' '
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	setup_repo hg hgrepo &&
-	(
-	cd hgrepo &&
-	setup_repo hg sub_hg_a &&
-	setup_repo hg sub_hg_b &&
-	setup_repo git sub_git &&
-	echo "sub_hg_a = sub_hg_a" > .hgsub &&
-	echo "sub_hg_b = sub_hg_b" >> .hgsub &&
-	echo "sub_git = [git]sub_git" >> .hgsub &&
-	hg add .hgsub &&
-	hg commit -m substate
-	)
-
-	git clone hg::hgrepo gitrepo &&
-
-	(
-	cd gitrepo &&
-	git-hg-helper sub update --force &&
-	test -f content_hgrepo &&
-	test -f sub_hg_a/content_sub_hg_a &&
-	test -f sub_hg_b/content_sub_hg_b &&
-	test -f sub_git/content_sub_git
-	) &&
-
-	check gitrepo HEAD substate &&
-	check gitrepo/sub_hg_a HEAD zero_sub_hg_a &&
-	check gitrepo/sub_hg_b HEAD zero_sub_hg_b &&
-	check gitrepo/sub_git HEAD zero_sub_git
-'
-
-setup_subrepos () {
-	setup_repo hg hgrepo &&
-	(
-	cd hgrepo &&
-	setup_repo hg sub_hg_a &&
-		(
-		cd sub_hg_a &&
-		setup_repo hg sub_hg_a_x &&
-		echo "sub_hg_a_x = sub_hg_a_x" > .hgsub &&
-		hg add .hgsub &&
-		hg commit -m substate_hg_a
-		) &&
-	setup_repo hg sub_hg_b &&
-		(
-		cd sub_hg_b &&
-		setup_repo git sub_git &&
-		echo "sub_git = [git]sub_git" > .hgsub &&
-		hg add .hgsub &&
-		hg commit -m substate_hg_b
-		) &&
-	echo "sub_hg_a = sub_hg_a" > .hgsub &&
-	echo "sub_hg_b = sub_hg_b" >> .hgsub &&
-	hg add .hgsub &&
-	hg commit -m substate
-	)
-}
-
-test_expect_success 'subcommand sub initial recursive update' '
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	setup_subrepos &&
-
-	git clone hg::hgrepo gitrepo &&
-
-	(
-	cd gitrepo &&
-	git-hg-helper sub --recursive update --force &&
-	test -f content_hgrepo &&
-	test -f sub_hg_a/content_sub_hg_a &&
-	test -f sub_hg_a/sub_hg_a_x/content_sub_hg_a_x &&
-	test -f sub_hg_b/content_sub_hg_b &&
-	test -f sub_hg_b/sub_git/content_sub_git
-	) &&
-
-	check gitrepo HEAD substate &&
-	check gitrepo/sub_hg_a HEAD substate_hg_a &&
-	check gitrepo/sub_hg_b HEAD substate_hg_b &&
-	check gitrepo/sub_hg_a/sub_hg_a_x HEAD zero_sub_hg_a_x &&
-	check gitrepo/sub_hg_b/sub_git HEAD zero_sub_git
-'
-
-test_sub_update () {
-	export option=$1
-
-	setup_subrepos &&
-
-	git clone hg::hgrepo gitrepo &&
-
-	(
-	cd gitrepo &&
-	git-hg-helper sub --recursive update --force
-	) &&
-
-	(
-	cd hgrepo &&
-		(
-		 cd sub_hg_a &&
-			(
-			cd sub_hg_a_x &&
-			echo one > content_sub_hg_a_x &&
-			hg commit -m one_sub_hg_a_x
-			) &&
-		hg commit -m substate_updated_hg_a
-		) &&
-	hg commit -m substate_updated
-	) &&
-
-	(
-	cd gitrepo &&
-	git fetch origin &&
-	git merge origin/master &&
-	git-hg-helper sub --recursive update --force $option &&
-	test -f content_hgrepo &&
-	test -f sub_hg_a/content_sub_hg_a &&
-	test -f sub_hg_a/sub_hg_a_x/content_sub_hg_a_x &&
-	test -f sub_hg_b/content_sub_hg_b &&
-	test -f sub_hg_b/sub_git/content_sub_git
-	) &&
-
-	check gitrepo HEAD substate_updated &&
-	check gitrepo/sub_hg_a HEAD substate_updated_hg_a &&
-	check gitrepo/sub_hg_b HEAD substate_hg_b &&
-	check gitrepo/sub_hg_a/sub_hg_a_x HEAD one_sub_hg_a_x &&
-	check gitrepo/sub_hg_b/sub_git HEAD zero_sub_git
-}
-
-test_expect_success 'subcommand sub subsequent recursive update' '
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	test_sub_update
-'
-
-test_expect_success 'subcommand sub subsequent recursive update -- rebase' '
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	test_sub_update --rebase
-'
-
-test_expect_success 'subcommand sub subsequent recursive update -- merge' '
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	test_sub_update --merge
-'
-
-check_foreach_vars () {
-	cat $1 | while read kind sha1 rev path remainder
-	do
-	    ok=0
-	    if test "$kind" = "hg" ; then
-			if test "$sha1" != "$rev" ; then
-				ok=1
-			fi
-	    else
-			if test "$sha1" = "$rev" ; then
-				ok=1
-			fi
-	    fi
-	    test $ok -eq 1 || echo "invalid $kind $sha1 $rev $path"
-	    test $ok -eq 1 || return 1
-	done &&
-
-	return 0
-}
-
-test_sub_foreach () {
-	setup_subrepos &&
-
-	git clone hg::hgrepo gitrepo &&
-
-	(
-	cd gitrepo &&
-	git-hg-helper sub --recursive update --force &&
-	git-hg-helper sub --recursive --quiet foreach 'echo $kind $sha1 $rev $path $toplevel' > output &&
-	cat output &&
-	echo 1 > expected_git &&
-	grep -c ^git output > actual_git &&
-	test_cmp expected_git actual_git &&
-	echo 3 > expected_hg &&
-	grep -c ^hg output > actual_hg &&
-	test_cmp expected_hg actual_hg &&
-	grep '\(hg\|git\) [0-9a-f]* [0-9a-f]* sub[^ ]* /.*' output > actual &&
-	test_cmp output actual &&
-	check_foreach_vars output
-	)
-}
-
-test_expect_success 'subcommand sub foreach' '
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	test_sub_foreach
-'
-
-test_expect_success 'subcommand sub sync' '
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	setup_repo hg hgrepo &&
-	(
-	cd hgrepo &&
-	setup_repo hg sub_hg &&
-	echo "sub_hg = sub_hg" > .hgsub &&
-	hg add .hgsub &&
-	hg commit -m substate
-	)
-
-	git clone hg::hgrepo gitrepo &&
-
-	(
-	cd gitrepo &&
-	git-hg-helper sub update --force &&
-
-		(
-		cd sub_hg &&
-		grep url .git/config > ../expected &&
-		git config remote.origin.url foobar &&
-		grep foobar .git/config
-		) &&
-
-	git-hg-helper sub sync &&
-	grep url sub_hg/.git/config > actual &&
-	test_cmp expected actual
-	)
-'
-
-test_expect_success 'subcommand sub addstate' '
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	setup_repo hg hgrepo &&
-	(
-	cd hgrepo &&
-	setup_repo hg sub_hg &&
-	setup_repo git sub_git &&
-	echo "sub_hg = sub_hg" > .hgsub &&
-	echo "sub_git = [git]sub_git" >> .hgsub &&
-	hg add .hgsub &&
-	hg commit -m substate
-	)
-
-	git clone hg::hgrepo gitrepo &&
-
-	(
-	cd gitrepo &&
-	git-hg-helper sub update --force &&
-
-		(
-		cd sub_hg &&
-		echo one > content_sub_hg &&
-		git add content_sub_hg &&
-		git commit -m one_sub_hg &&
-		# detached HEAD
-		git push origin HEAD:master &&
-		# also fetch to ensure notes are updated
-		git fetch origin
-		) &&
-
-		(
-		cd sub_git &&
-		echo one > content_sub_git &&
-		git add content_sub_git &&
-		git commit -m one_sub_git &&
-		# detached HEAD; push revision to other side ... anywhere
-		git push origin HEAD:refs/heads/new
-		)
-	) &&
-
-	(
-	cd gitrepo &&
-	git-hg-helper sub upstate &&
-	git diff &&
-	git status --porcelain | grep .hgsubstate &&
-	git add .hgsubstate &&
-	git commit -m update_sub &&
-	git push origin master
-	) &&
-
-	hg clone hgrepo hgclone &&
-
-	(
-	cd hgclone &&
-	hg update
-	) &&
-
-	check_branch hgclone default update_sub &&
-	check_branch hgclone/sub_hg default one_sub_hg &&
-	check hgclone/sub_git HEAD one_sub_git
-'
-
-test_expect_success 'subcommand sub status' '
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	setup_repo hg hgrepo &&
-	(
-	cd hgrepo &&
-	setup_repo hg sub_hg_a &&
-	setup_repo hg sub_hg_b &&
-	setup_repo git sub_git &&
-	echo "sub_hg_a = sub_hg_a" > .hgsub &&
-	echo "sub_hg_b = sub_hg_b" >> .hgsub &&
-	echo "sub_git = [git]sub_git" >> .hgsub &&
-	hg add .hgsub &&
-	hg commit -m substate
-	)
-
-	git clone hg::hgrepo gitrepo &&
-
-	(
-	cd gitrepo &&
-	git-hg-helper sub update --force sub_hg_a  &&
-	git-hg-helper sub update --force sub_git &&
-		(
-		# advance and add a tag to the git repo
-		cd sub_git &&
-		echo one > content_sub_git &&
-		git add content_sub_git &&
-		git commit -m one_sub_git &&
-		git tag feature-a
-		) &&
-
-	git-hg-helper sub status --cached > output &&
-	cat output &&
-	grep "^ .*sub_hg_a (.*master.*)$" output &&
-	grep "^-.*sub_hg_b$" output &&
-	grep "^+.*sub_git (feature-a~1)$" output &&
-	git-hg-helper sub status sub_git > output &&
-	cat output &&
-	grep "^+.*sub_git (feature-a)$" output > actual &&
-	test_cmp output actual
-	)
-'
-
-test_done

t/hg-git.t

@@ -1,446 +0,0 @@
-#!/bin/bash
-#
-# Copyright (c) 2012 Felipe Contreras
-#
-# Base commands from hg-git tests:
-# https://bitbucket.org/durin42/hg-git/src
-#
-
-# shellcheck disable=SC2016,SC2034,SC2086,SC2164,SC1091
-
-test_description='Test remote-hg output compared to hg-git'
-
-. "$(dirname "$0")"/test-lib.sh
-
-export EXPECTED_DIR="$SHARNESS_TEST_DIRECTORY/expected"
-
-git_clone () {
-	git clone -q "hg::$1" $2 &&
-	(
-	cd $2 &&
-	git checkout master &&
-	{ git branch -D default || true ;}
-	)
-}
-
-hg_clone () {
-	(
-	hg init $2 &&
-	hg -R $2 bookmark -i master &&
-	cd $1 &&
-	git push -q "hg::../$2" 'refs/tags/*:refs/tags/*' 'refs/heads/*:refs/heads/*'
-	) &&
-
-	(cd $2 && hg -q update)
-}
-
-hg_push () {
-	(
-	cd $2
-	git checkout -q -b tmp &&
-	git fetch -q "hg::../$1" 'refs/tags/*:refs/tags/*' 'refs/heads/*:refs/heads/*' &&
-	git branch -D default &&
-	git checkout -q '@{-1}' &&
-	{ git branch -q -D tmp 2> /dev/null || true ;}
-	)
-}
-
-hg_log () {
-	hg -R $1 log --debug -r 'sort(tip:0, date)' |
-		sed -e '/tag: *default/d' -e 's/[0-9]\+:\([0-9a-f]\{40\}\)/\1/'
-}
-
-git_log () {
-	git -C $1 fast-export --branches
-}
-
-test_cmp_expected () {
-	test_cmp "$EXPECTED_DIR/$test_id/$1" "$1"
-}
-
-cmp_hg_to_git_log () {
-	hg_log hgrepo2 > hg-log &&
-	git_log gitrepo > git-log &&
-
-	test_cmp_expected hg-log &&
-	test_cmp_expected git-log
-}
-
-cmp_hg_to_git_log_hgrepo1 () {
-	git_clone hgrepo1 gitrepo &&
-	hg_clone gitrepo hgrepo2 &&
-
-	cmp_hg_to_git_log
-}
-
-cmp_hg_to_git_manifest () {
-	(
-	hg_clone gitrepo hgrepo &&
-	cd hgrepo &&
-	hg_log . &&
-	eval "$1"
-	) > output &&
-
-	git_clone hgrepo gitrepo2 &&
-	git_log gitrepo2 > log &&
-
-	test_cmp_expected output &&
-	test_cmp_expected log
-}
-
-setup () {
-	cat > "$HOME"/.hgrc <<-EOF
-	[ui]
-	username = A U Thor <author@example.com>
-	[defaults]
-	commit = -d "0 0"
-	tag = -d "0 0"
-	EOF
-
-	cat > "$HOME"/.gitconfig <<-EOF
-	[remote-hg]
-		hg-git-compat = true
-		track-branches = false
-		# directly use local repo to avoid push (and hence phase issues)
-		shared-marks = false
-	EOF
-
-	export HGEDITOR=true
-	export HGMERGE=true
-
-	export GIT_AUTHOR_DATE="2007-01-01 00:00:00 +0230"
-	export GIT_COMMITTER_DATE="$GIT_AUTHOR_DATE"
-}
-
-setup
-
-# save old function
-eval "old_$(declare -f test_expect_success)"
-
-test_expect_success () {
-	local req
-	test "$#" = 3 && { req=$1; shift; } || req=
-	test_id="$1"
-	old_test_expect_success "$req" "$1" "
-	test_when_finished \"rm -rf gitrepo* hgrepo*\" && $2"
-}
-
-test_expect_success 'rename' '
-	(
-	hg init hgrepo1 &&
-	cd hgrepo1 &&
-	echo alpha > alpha &&
-	hg add alpha &&
-	hg commit -m "add alpha" &&
-	hg mv alpha beta &&
-	hg commit -m "rename alpha to beta"
-	) &&
-
-	cmp_hg_to_git_log_hgrepo1
-'
-
-test_expect_success !WIN 'executable bit' '
-	(
-	git init -q gitrepo &&
-	cd gitrepo &&
-	echo alpha > alpha &&
-	chmod 0644 alpha &&
-	git add alpha &&
-	git commit -m "add alpha" &&
-	chmod 0755 alpha &&
-	git add alpha &&
-	git commit -m "set executable bit" &&
-	chmod 0644 alpha &&
-	git add alpha &&
-	git commit -m "clear executable bit"
-	) &&
-
-	cmp_hg_to_git_manifest "hg manifest -v -r -1; hg manifest -v"
-'
-
-test_expect_success !WIN 'symlink' '
-	(
-	git init -q gitrepo &&
-	cd gitrepo &&
-	echo alpha > alpha &&
-	git add alpha &&
-	git commit -m "add alpha" &&
-	ln -s alpha beta &&
-	git add beta &&
-	git commit -m "add beta"
-	) &&
-
-	cmp_hg_to_git_manifest "hg manifest -v"
-'
-
-test_expect_success 'merge conflict 1' '
-	(
-	hg init hgrepo1 &&
-	cd hgrepo1 &&
-	echo A > afile &&
-	hg add afile &&
-	hg ci -m "origin" &&
-
-	echo B > afile &&
-	hg ci -m "A->B" -d "1 0" &&
-
-	hg up -r0 &&
-	echo C > afile &&
-	hg ci -m "A->C" -d "2 0" &&
-
-	hg merge -r1 &&
-	echo C > afile &&
-	hg resolve -m afile &&
-	hg ci -m "merge to C" -d "3 0"
-	) &&
-
-	cmp_hg_to_git_log_hgrepo1
-'
-
-test_expect_success 'merge conflict 2' '
-	(
-	hg init hgrepo1 &&
-	cd hgrepo1 &&
-	echo A > afile &&
-	hg add afile &&
-	hg ci -m "origin" &&
-
-	echo B > afile &&
-	hg ci -m "A->B" -d "1 0" &&
-
-	hg up -r0 &&
-	echo C > afile &&
-	hg ci -m "A->C" -d "2 0" &&
-
-	hg merge -r1 || true &&
-	echo B > afile &&
-	hg resolve -m afile &&
-	hg ci -m "merge to B" -d "3 0"
-	) &&
-
-	cmp_hg_to_git_log_hgrepo1
-'
-
-test_expect_success 'converged merge' '
-	(
-	hg init hgrepo1 &&
-	cd hgrepo1 &&
-	echo A > afile &&
-	hg add afile &&
-	hg ci -m "origin" &&
-
-	echo B > afile &&
-	hg ci -m "A->B" -d "1 0" &&
-
-	echo C > afile &&
-	hg ci -m "B->C" -d "2 0" &&
-
-	hg up -r0 &&
-	echo C > afile &&
-	hg ci -m "A->C" -d "3 0" &&
-
-	hg merge -r2 || true &&
-	hg ci -m "merge" -d "4 0"
-	) &&
-
-	cmp_hg_to_git_log_hgrepo1
-'
-
-test_expect_success 'encoding' '
-	(
-	git init -q gitrepo &&
-	cd gitrepo &&
-
-	echo alpha > alpha &&
-	git add alpha &&
-	git commit -m "add älphà" &&
-
-	GIT_AUTHOR_NAME="tést èncödîng" &&
-	export GIT_AUTHOR_NAME &&
-	echo beta > beta &&
-	git add beta &&
-	git commit -m "add beta" &&
-
-	echo gamma > gamma &&
-	git add gamma &&
-	git commit -m "add gämmâ" &&
-
-	: TODO git config i18n.commitencoding latin-1 &&
-	echo delta > delta &&
-	git add delta &&
-	git commit -m "add déltà"
-	) &&
-
-	hg_clone gitrepo hgrepo &&
-	git_clone hgrepo gitrepo2 &&
-
-	HGENCODING=utf-8 hg_log hgrepo > hg-log &&
-	git_log gitrepo2 > git-log &&
-
-	test_cmp_expected hg-log &&
-	test_cmp_expected git-log
-'
-
-test_expect_success 'file removal' '
-	(
-	git init -q gitrepo &&
-	cd gitrepo &&
-	echo alpha > alpha &&
-	git add alpha &&
-	git commit -m "add alpha" &&
-	echo beta > beta &&
-	git add beta &&
-	git commit -m "add beta"
-	mkdir foo &&
-	echo blah > foo/bar &&
-	git add foo &&
-	git commit -m "add foo" &&
-	git rm alpha &&
-	git commit -m "remove alpha" &&
-	git rm foo/bar &&
-	git commit -m "remove foo/bar"
-	) &&
-
-	cmp_hg_to_git_manifest "hg manifest -r 3; hg manifest"
-'
-
-test_expect_success 'git tags' '
-	(
-	git init -q gitrepo &&
-	cd gitrepo &&
-	git config receive.denyCurrentBranch ignore &&
-	echo alpha > alpha &&
-	git add alpha &&
-	git commit -m "add alpha" &&
-	git tag alpha &&
-
-	echo beta > beta &&
-	git add beta &&
-	git commit -m "add beta" &&
-	git tag -a -m "added tag beta" beta
-	) &&
-
-	hg_clone gitrepo hgrepo &&
-	hg_log hgrepo > log &&
-
-	test_cmp_expected log
-'
-
-test_expect_success 'hg author' '
-	(
-	git init -q gitrepo &&
-	cd gitrepo &&
-
-	echo alpha > alpha &&
-	git add alpha &&
-	git commit -m "add alpha" &&
-	git checkout -q -b not-master
-	) &&
-
-	(
-	hg_clone gitrepo hgrepo &&
-	cd hgrepo &&
-
-	hg co master &&
-	echo beta > beta &&
-	hg add beta &&
-	hg commit -u "test" -m "add beta" &&
-
-	echo gamma >> beta &&
-	hg commit -u "test <test@example.com> (comment)" -m "modify beta" &&
-
-	echo gamma > gamma &&
-	hg add gamma &&
-	hg commit -u "<test@example.com>" -m "add gamma" &&
-
-	echo delta > delta &&
-	hg add delta &&
-	hg commit -u "name<test@example.com>" -m "add delta" &&
-
-	echo epsilon > epsilon &&
-	hg add epsilon &&
-	hg commit -u "name <test@example.com" -m "add epsilon" &&
-
-	echo zeta > zeta &&
-	hg add zeta &&
-	hg commit -u " test " -m "add zeta" &&
-
-	echo eta > eta &&
-	hg add eta &&
-	hg commit -u "test < test@example.com >" -m "add eta" &&
-
-	echo theta > theta &&
-	hg add theta &&
-	hg commit -u "test >test@example.com>" -m "add theta" &&
-
-	echo iota > iota &&
-	hg add iota &&
-	hg commit -u "test <test <at> example <dot> com>" -m "add iota"
-	) &&
-
-	hg_push hgrepo gitrepo &&
-	hg_clone gitrepo hgrepo2 &&
-
-	cmp_hg_to_git_log
-'
-
-test_expect_success 'hg branch' '
-	(
-	git init -q gitrepo &&
-	cd gitrepo &&
-
-	echo alpha > alpha &&
-	git add alpha &&
-	git commit -q -m "add alpha" &&
-	git checkout -q -b not-master
-	) &&
-
-	(
-	hg_clone gitrepo hgrepo &&
-
-	cd hgrepo &&
-	hg -q co master &&
-	hg mv alpha beta &&
-	hg -q commit -m "rename alpha to beta" &&
-	hg branch gamma | grep -v "permanent and global" &&
-	hg -q commit -m "started branch gamma"
-	) &&
-
-	hg_push hgrepo gitrepo &&
-	hg_clone gitrepo hgrepo2 &&
-
-	cmp_hg_to_git_log
-'
-
-test_expect_success 'hg tags' '
-	(
-	git init -q gitrepo &&
-	cd gitrepo &&
-
-	echo alpha > alpha &&
-	git add alpha &&
-	git commit -m "add alpha" &&
-	git checkout -q -b not-master
-	) &&
-
-	(
-	hg_clone gitrepo hgrepo &&
-
-	cd hgrepo &&
-	hg co master &&
-	hg tag alpha
-	) &&
-
-	hg_push hgrepo gitrepo &&
-	hg_clone gitrepo hgrepo2 &&
-
-	(
-	git -C gitrepo tag -l &&
-	hg_log hgrepo2 &&
-	cat hgrepo2/.hgtags
-	) > output &&
-
-	test_cmp_expected output
-'
-
-test_done

t/main-push.t

@@ -1,314 +0,0 @@
-#!/bin/bash
-
-CAPABILITY_PUSH=t
-
-. "$(dirname "$0")"/main.t
-
-# .. and some push mode only specific tests
-
-test_expect_success 'remote delete bookmark' '
-	test_when_finished "rm -rf hgrepo* gitrepo*" &&
-
-	(
-	hg init hgrepo &&
-	cd hgrepo &&
-	echo zero > content &&
-	hg add content &&
-	hg commit -m zero
-	hg bookmark feature-a
-	) &&
-
-	git clone "hg::hgrepo" gitrepo &&
-	check_bookmark hgrepo feature-a zero &&
-
-	(
-	cd gitrepo &&
-	git push --quiet origin :feature-a
-	) &&
-
-	check_bookmark hgrepo feature-a ''
-'
-
-test_expect_success 'source:dest bookmark' '
-	test_when_finished "rm -rf hgrepo gitrepo" &&
-
-	(
-	hg init hgrepo &&
-	cd hgrepo &&
-	echo zero > content &&
-	hg add content &&
-	hg commit -m zero
-	) &&
-
-	git clone "hg::hgrepo" gitrepo &&
-
-	(
-	cd gitrepo &&
-	echo one > content &&
-	git commit -a -m one &&
-	git push --quiet origin master:feature-b &&
-	git push --quiet origin master^:refs/heads/feature-a
-	) &&
-
-	check_bookmark hgrepo feature-a zero &&
-	check_bookmark hgrepo feature-b one &&
-
-	(
-	cd gitrepo &&
-	git push --quiet origin master:feature-a
-	) &&
-
-	check_bookmark hgrepo feature-a one
-'
-
-setup_check_hg_commits_repo () {
-        (
-	rm -rf hgrepo* &&
-	hg init hgrepo &&
-	cd hgrepo &&
-	echo zero > content &&
-	hg add content &&
-	hg commit -m zero
-	) &&
-
-	git clone "hg::hgrepo" gitrepo &&
-	hg clone hgrepo hgrepo.second &&
-
-	(
-	cd gitrepo &&
-	git remote add second hg::../hgrepo.second &&
-	git fetch second
-	) &&
-
-	(
-	cd hgrepo &&
-	echo one > content &&
-	hg commit -m one &&
-	echo two > content &&
-	hg commit -m two &&
-	echo three > content &&
-	hg commit -m three &&
-	hg move content content-move &&
-	hg commit -m moved &&
-	hg move content-move content &&
-	hg commit -m restored
-        )
-}
-
-# a shared bag would make all of the following pretty trivial
-git config --global remote-hg.shared-marks false
-
-git config --global remote-hg.check-hg-commits fail
-test_expect_success 'check-hg-commits with fail mode' '
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	setup_check_hg_commits_repo &&
-
-	(
-	cd gitrepo &&
-	git fetch origin &&
-	git reset --hard origin/master &&
-	! git push second master 2>../error
-	)
-
-	cat error &&
-	grep rejected error | grep hg
-'
-
-git config --global remote-hg.check-hg-commits push
-# codepath for push is slightly different depending on shared proxy involved
-# so tweak to test both
-check_hg_commits_push () {
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	setup_check_hg_commits_repo &&
-
-	(
-	cd gitrepo &&
-	git fetch origin &&
-	git reset --hard origin/master &&
-	git push second master 2> ../error
-	) &&
-
-	cat error &&
-	grep "hg changeset" error &&
-
-	hg log -R hgrepo > expected &&
-	hg log -R hgrepo.second | grep -v bookmark > actual &&
-	test_cmp expected actual
-}
-
-unset GIT_REMOTE_HG_TEST_REMOTE
-test_expect_success 'check-hg-commits with push mode - no local proxy' '
-	check_hg_commits_push
-'
-
-GIT_REMOTE_HG_TEST_REMOTE=1 &&
-export GIT_REMOTE_HG_TEST_REMOTE
-test_expect_success 'check-hg-commits with push mode - with local proxy' '
-	check_hg_commits_push
-'
-
-setup_check_shared_marks_repo () {
-        (
-	rm -rf hgrepo* &&
-	hg init hgrepo &&
-	cd hgrepo &&
-	echo zero > content &&
-	hg add content &&
-	hg commit -m zero
-	) &&
-
-	git clone "hg::hgrepo" gitrepo &&
-
-	(
-	cd gitrepo &&
-	git remote add second hg::../hgrepo &&
-	git fetch second
-	)
-}
-
-check_marks () {
-	dir=$1
-
-	ls -al $dir &&
-	if test "$2" = "y"
-	then
-		test -f $dir/marks-git && test -f $dir/marks-hg
-	else
-		test ! -f $dir/marks-git && test ! -f $dir/marks-hg
-	fi
-}
-
-# cleanup setting
-git config --global --unset remote-hg.shared-marks
-
-test_expect_success 'shared-marks unset' '
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	setup_check_shared_marks_repo &&
-
-	(
-	cd gitrepo &&
-	check_marks .git/hg y &&
-	check_marks .git/hg/origin n &&
-	check_marks .git/hg/second n
-	)
-'
-
-test_expect_success 'shared-marks set to unset' '
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	git config --global remote-hg.shared-marks true &&
-	setup_check_shared_marks_repo &&
-
-	(
-	cd gitrepo &&
-	check_marks .git/hg y &&
-	check_marks .git/hg/origin n &&
-	check_marks .git/hg/second n
-	) &&
-
-	git config --global remote-hg.shared-marks false &&
-	(
-		cd gitrepo &&
-		git fetch origin &&
-		check_marks .git/hg n &&
-		check_marks .git/hg/origin y &&
-		check_marks .git/hg/second y
-	)
-'
-
-test_expect_success 'shared-marks unset to set' '
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	git config --global remote-hg.shared-marks false &&
-	setup_check_shared_marks_repo &&
-
-	(
-	cd gitrepo &&
-	check_marks .git/hg n &&
-	check_marks .git/hg/origin y &&
-	check_marks .git/hg/second y
-	) &&
-
-	git config --global --unset remote-hg.shared-marks &&
-	(
-		cd gitrepo &&
-		git fetch origin &&
-		check_marks .git/hg n &&
-		check_marks .git/hg/origin y &&
-		check_marks .git/hg/second y
-	) &&
-
-	git config --global remote-hg.shared-marks true &&
-	(
-		cd gitrepo &&
-		git fetch origin &&
-		check_marks .git/hg y &&
-		check_marks .git/hg/origin n &&
-		check_marks .git/hg/second n
-	)
-'
-
-test_expect_success 'push with renamed executable preserves executable bit' '
-	test_when_finished "rm -rf hgrepo gitrepo*" &&
-
-	hg init hgrepo &&
-
-	(
-	git init gitrepo &&
-	cd gitrepo &&
-	git remote add origin "hg::../hgrepo" &&
-	echo one > content &&
-	chmod a+x content &&
-	git add content &&
-	git commit -a -m one &&
-	git mv content content2 &&
-	git commit -a -m two &&
-	git push origin master
-	) &&
-
-	(
-	umask 0 &&
-	cd hgrepo &&
-	hg update &&
-	stat content2 >expected &&
-	grep -- -r.xr.xr.x expected
-	)
-'
-
-test_expect_success 'push with submodule' '
-	test_when_finished "rm -rf sub hgrepo gitrepo*" &&
-
-	hg init hgrepo &&
-
-	(
-	git init sub &&
-	cd sub &&
-	: >empty &&
-	git add empty &&
-	git commit -m init
-	) &&
-
-	(
-	git init gitrepo &&
-	cd gitrepo &&
-	git submodule add ../sub sub &&
-	git remote add origin "hg::../hgrepo" &&
-	git commit -a -m sub &&
-	git push origin master
-	) &&
-
-	(
-	cd hgrepo &&
-	hg update &&
-	expected="[git-remote-hg: skipped import of submodule at $(git -C ../sub rev-parse HEAD)]"
-	test "$expected" = "$(cat sub)"
-	)
-'
-
-# cleanup setting
-git config --global --unset remote-hg.shared-marks
-
-test_done

t/sharness.sh

@@ -1,760 +0,0 @@
-# Sharness test framework.
-#
-# Copyright (c) 2011-2012 Mathias Lafeldt
-# Copyright (c) 2005-2012 Git project
-# Copyright (c) 2005-2012 Junio C Hamano
-# Copyright (c) 2019-2023 Felipe Contreras
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see http://www.gnu.org/licenses/ .
-
-if test -n "${ZSH_VERSION-}"
-then
-	# shellcheck disable=SC2296
-	SHARNESS_SOURCE=${(%):-%x}
-	emulate sh -o POSIX_ARGZERO
-else
-	# shellcheck disable=SC3028
-	SHARNESS_SOURCE=${BASH_SOURCE-$0}
-fi
-
-# Public: Current version of Sharness.
-SHARNESS_VERSION="1.2.1"
-export SHARNESS_VERSION
-
-: "${SHARNESS_TEST_EXTENSION:=t}"
-# Public: The file extension for tests.  By default, it is set to "t".
-export SHARNESS_TEST_EXTENSION
-
-: "${SHARNESS_TEST_DIRECTORY:=$(dirname "$0")}"
-# ensure that SHARNESS_TEST_DIRECTORY is an absolute path so that it
-# is valid even if the current working directory is changed
-SHARNESS_TEST_DIRECTORY=$(cd "$SHARNESS_TEST_DIRECTORY" && pwd) || exit 1
-# Public: Root directory containing tests. Tests can override this variable,
-# e.g. for testing Sharness itself.
-export SHARNESS_TEST_DIRECTORY
-
-: "${SHARNESS_TEST_SRCDIR:=$(cd "$(dirname "$SHARNESS_SOURCE")" && pwd)}"
-# Public: Source directory of test code and sharness library.
-# This directory may be different from the directory in which tests are
-# being run.
-export SHARNESS_TEST_SRCDIR
-
-: "${SHARNESS_TEST_OUTDIR:=$SHARNESS_TEST_DIRECTORY}"
-# Public: Directory where the output of the tests should be stored (i.e.
-# trash directories).
-export SHARNESS_TEST_OUTDIR
-
-#  Reset TERM to original terminal if found, otherwise save original TERM
-[ -z "$SHARNESS_ORIG_TERM" ] &&
-		SHARNESS_ORIG_TERM="$TERM" ||
-		TERM="$SHARNESS_ORIG_TERM"
-# Public: The unsanitized TERM under which sharness is originally run
-export SHARNESS_ORIG_TERM
-
-# Export SHELL_PATH
-: "${SHELL_PATH:=/bin/sh}"
-export SHELL_PATH
-
-# if --tee was passed, write the output not only to the terminal, but
-# additionally to the file test-results/$BASENAME.out, too.
-case "$SHARNESS_TEST_TEE_STARTED, $* " in
-done,*)
-	# do not redirect again
-	;;
-*' --tee '*|*' --verbose-log '*)
-	mkdir -p "$SHARNESS_TEST_OUTDIR/test-results"
-	BASE="$SHARNESS_TEST_OUTDIR/test-results/$(basename "$0" ".$SHARNESS_TEST_EXTENSION")"
-
-	# Make this filename available to the sub-process in case it is using
-	# --verbose-log.
-	SHARNESS_TEST_TEE_OUTPUT_FILE="$BASE.out"
-	export SHARNESS_TEST_TEE_OUTPUT_FILE
-
-	# Truncate before calling "tee -a" to get rid of the results
-	# from any previous runs.
-	: >"$SHARNESS_TEST_TEE_OUTPUT_FILE"
-
-	(SHARNESS_TEST_TEE_STARTED="done" ${SHELL_PATH} "$0" "$@" 2>&1;
-	 echo $? >"$BASE.exit") | tee -a "$SHARNESS_TEST_TEE_OUTPUT_FILE"
-	test "$(cat "$BASE.exit")" = 0
-	exit
-	;;
-esac
-
-# For repeatability, reset the environment to a known state.
-# TERM is sanitized below, after saving color control sequences.
-LANG=C
-LC_ALL=C
-PAGER="cat"
-TZ=UTC
-EDITOR=:
-export LANG LC_ALL PAGER TZ EDITOR
-unset VISUAL CDPATH GREP_OPTIONS
-
-[ "x$TERM" != "xdumb" ] && (
-		[ -t 1 ] &&
-		tput bold >/dev/null 2>&1 &&
-		tput setaf 1 >/dev/null 2>&1 &&
-		tput sgr0 >/dev/null 2>&1
-	) &&
-	color=t
-
-while test "$#" -ne 0; do
-	case "$1" in
-	-d|--d|--de|--deb|--debu|--debug)
-		debug=t; shift ;;
-	-i|--i|--im|--imm|--imme|--immed|--immedi|--immedia|--immediat|--immediate)
-		immediate=t; shift ;;
-	-l|--l|--lo|--lon|--long|--long-|--long-t|--long-te|--long-tes|--long-test|--long-tests)
-		TEST_LONG=t; export TEST_LONG; shift ;;
-	--in|--int|--inte|--inter|--intera|--interac|--interact|--interacti|--interactiv|--interactive|--interactive-|--interactive-t|--interactive-te|--interactive-tes|--interactive-test|--interactive-tests):
-		TEST_INTERACTIVE=t; export TEST_INTERACTIVE; verbose=t; shift ;;
-	-h|--h|--he|--hel|--help)
-		help=t; shift ;;
-	-v|--v|--ve|--ver|--verb|--verbo|--verbos|--verbose)
-		verbose=t; shift ;;
-	-q|--q|--qu|--qui|--quie|--quiet)
-		# Ignore --quiet under a TAP::Harness. Saying how many tests
-		# passed without the ok/not ok details is always an error.
-		test -z "$HARNESS_ACTIVE" && quiet=t; shift ;;
-	--chain-lint)
-		chain_lint=t; shift ;;
-	--no-chain-lint)
-		chain_lint=; shift ;;
-	--no-color)
-		color=; shift ;;
-	--tee)
-		shift ;; # was handled already
-	--root=*)
-		root=$(expr "z$1" : 'z[^=]*=\(.*\)')
-		shift ;;
-	-x)
-		trace=t
-		shift ;;
-	--verbose-log)
-		verbose_log=t
-		shift ;;
-	*)
-		echo "error: unknown test option '$1'" >&2; exit 1 ;;
-	esac
-done
-
-if test -n "$color"; then
-	# Save the color control sequences now rather than run tput
-	# each time say_color() is called.  This is done for two
-	# reasons:
-	#   * TERM will be changed to dumb
-	#   * HOME will be changed to a temporary directory and tput
-	#     might need to read ~/.terminfo from the original HOME
-	#     directory to get the control sequences
-	# Note:  This approach assumes the control sequences don't end
-	# in a newline for any terminal of interest (command
-	# substitutions strip trailing newlines).  Given that most
-	# (all?) terminals in common use are related to ECMA-48, this
-	# shouldn't be a problem.
-	say_color_error=$(tput bold; tput setaf 1) # bold red
-	say_color_skip=$(tput setaf 4) # blue
-	say_color_warn=$(tput setaf 3) # brown/yellow
-	say_color_pass=$(tput setaf 2) # green
-	say_color_info=$(tput setaf 6) # cyan
-	say_color_reset=$(tput sgr0)
-	say_color_raw="" # no formatting for normal text
-	say_color() {
-		test -z "$1" && test -n "$quiet" && return
-		case "$1" in
-			error) say_color_color=$say_color_error ;;
-			skip) say_color_color=$say_color_skip ;;
-			warn) say_color_color=$say_color_warn ;;
-			pass) say_color_color=$say_color_pass ;;
-			info) say_color_color=$say_color_info ;;
-			*) say_color_color=$say_color_raw ;;
-		esac
-		shift
-		printf '%s%s%s\n' "$say_color_color" "$*" "$say_color_reset"
-	}
-else
-	say_color() {
-		test -z "$1" && test -n "$quiet" && return
-		shift
-		printf '%s\n' "$*"
-	}
-fi
-
-: "${test_untraceable:=}"
-# Public: When set to a non-empty value, the current test will not be
-# traced, unless it's run with a Bash version supporting
-# BASH_XTRACEFD, i.e. v4.1 or later.
-export test_untraceable
-
-if test -n "$trace" && test -n "$test_untraceable"
-then
-	# '-x' tracing requested, but this test script can't be reliably
-	# traced, unless it is run with a Bash version supporting
-	# BASH_XTRACEFD (introduced in Bash v4.1).
-	#
-	# Perform this version check _after_ the test script was
-	# potentially re-executed with $TEST_SHELL_PATH for '--tee' or
-	# '--verbose-log', so the right shell is checked and the
-	# warning is issued only once.
-	if test -n "$BASH_VERSION" && eval '
-	     test ${BASH_VERSINFO[0]} -gt 4 || {
-	       test ${BASH_VERSINFO[0]} -eq 4 &&
-	       test ${BASH_VERSINFO[1]} -ge 1
-	     }
-	   '
-	then
-		: Executed by a Bash version supporting BASH_XTRACEFD.  Good.
-	else
-		echo >&2 "warning: ignoring -x; '$0' is untraceable without BASH_XTRACEFD"
-		trace=
-	fi
-fi
-if test -n "$trace" && test -z "$verbose_log"
-then
-	verbose=t
-fi
-
-TERM=dumb
-export TERM
-
-error() {
-	say_color error "error: $*"
-	EXIT_OK=t
-	exit 1
-}
-
-say() {
-	say_color info "$*"
-}
-
-test -n "${test_description:-}" || error "Test script did not set test_description."
-
-if test "$help" = "t"; then
-	echo "$test_description"
-	exit 0
-fi
-
-exec 5>&1
-exec 6<&0
-if test "$verbose_log" = "t"
-then
-	exec 3>>"$SHARNESS_TEST_TEE_OUTPUT_FILE" 4>&3
-elif test "$verbose" = "t"
-then
-	exec 4>&2 3>&1
-else
-	exec 4>/dev/null 3>/dev/null
-fi
-
-# Send any "-x" output directly to stderr to avoid polluting tests
-# which capture stderr. We can do this unconditionally since it
-# has no effect if tracing isn't turned on.
-#
-# Note that this sets up the trace fd as soon as we assign the variable, so it
-# must come after the creation of descriptor 4 above. Likewise, we must never
-# unset this, as it has the side effect of closing descriptor 4, which we
-# use to show verbose tests to the user.
-#
-# Note also that we don't need or want to export it. The tracing is local to
-# this shell, and we would not want to influence any shells we exec.
-BASH_XTRACEFD=4
-
-# Public: The current test number, starting at 0.
-SHARNESS_TEST_NB=0
-export SHARNESS_TEST_NB
-
-die() {
-	code=$?
-	if test -n "$EXIT_OK"; then
-		exit $code
-	else
-		echo >&5 "FATAL: Unexpected exit with code $code"
-		exit 1
-	fi
-}
-
-EXIT_OK=
-trap 'die' EXIT
-
-test_prereq=
-missing_prereq=
-
-test_failure=0
-test_fixed=0
-test_broken=0
-test_success=0
-
-if test -e "$SHARNESS_TEST_SRCDIR/lib-sharness/functions.sh"
-then
-	. "$SHARNESS_TEST_SRCDIR/lib-sharness/functions.sh"
-fi
-
-# You are not expected to call test_ok_ and test_failure_ directly, use
-# the text_expect_* functions instead.
-
-test_ok_() {
-	test_success=$((test_success + 1))
-	say_color "" "ok $SHARNESS_TEST_NB - $*"
-}
-
-test_failure_() {
-	test_failure=$((test_failure + 1))
-	say_color error "not ok $SHARNESS_TEST_NB - $1"
-	shift
-	echo "$@" | sed -e 's/^/#	/'
-	test "$immediate" = "" || { EXIT_OK=t; exit 1; }
-}
-
-test_known_broken_ok_() {
-	test_fixed=$((test_fixed + 1))
-	say_color error "ok $SHARNESS_TEST_NB - $* # TODO known breakage vanished"
-}
-
-test_known_broken_failure_() {
-	test_broken=$((test_broken + 1))
-	say_color warn "not ok $SHARNESS_TEST_NB - $* # TODO known breakage"
-}
-
-want_trace () {
-	test "$trace" = t && {
-		test "$verbose" = t || test "$verbose_log" = t
-	}
-}
-
-# This is a separate function because some tests use
-# "return" to end a test_expect_success block early
-# (and we want to make sure we run any cleanup like
-# "set +x").
-test_eval_inner_ () {
-	# Do not add anything extra (including LF) after '$*'
-	eval "
-		want_trace && set -x
-		$*"
-}
-
-test_eval_x_ () {
-	# If "-x" tracing is in effect, then we want to avoid polluting stderr
-	# with non-test commands. But once in "set -x" mode, we cannot prevent
-	# the shell from printing the "set +x" to turn it off (nor the saving
-	# of $? before that). But we can make sure that the output goes to
-	# /dev/null.
-	#
-	# There are a few subtleties here:
-	#
-	#   - we have to redirect descriptor 4 in addition to 2, to cover
-	#     BASH_XTRACEFD
-	#
-	#   - the actual eval has to come before the redirection block (since
-	#     it needs to see descriptor 4 to set up its stderr)
-	#
-	#   - likewise, any error message we print must be outside the block to
-	#     access descriptor 4
-	#
-	#   - checking $? has to come immediately after the eval, but it must
-	#     be _inside_ the block to avoid polluting the "set -x" output
-	#
-
-	test_eval_inner_ "$@" </dev/null >&3 2>&4
-	{
-		test_eval_ret_=$?
-		if want_trace
-		then
-			set +x
-		fi
-	} 2>/dev/null 4>&2
-
-	if test "$test_eval_ret_" != 0 && want_trace
-	then
-		say_color error >&4 "error: last command exited with \$?=$test_eval_ret_"
-	fi
-	return $test_eval_ret_
-}
-
-test_eval_() {
-	case ",$test_prereq," in
-	*,INTERACTIVE,*)
-		eval "$*"
-		;;
-	*)
-		test_eval_x_ "$@"
-		;;
-	esac
-}
-
-test_run_() {
-	test_cleanup=:
-	expecting_failure=$2
-	test_eval_ "$1"
-	eval_ret=$?
-
-	if test "$chain_lint" = "t"; then
-		# turn off tracing for this test-eval, as it simply creates
-		# confusing noise in the "-x" output
-		trace_tmp=$trace
-		trace=
-		# 117 is magic because it is unlikely to match the exit
-		# code of other programs
-		test_eval_ "(exit 117) && $1"
-		if test "$?" != 117; then
-			error "bug in the test script: broken &&-chain: $1"
-		fi
-		trace=$trace_tmp
-	fi
-
-	if test -z "$immediate" || test $eval_ret = 0 ||
-	   test -n "$expecting_failure" && test "$test_cleanup" != ":"
-	then
-		test_eval_ "$test_cleanup"
-	fi
-	if test "$verbose" = "t" && test -n "$HARNESS_ACTIVE"; then
-		echo ""
-	fi
-	return "$eval_ret"
-}
-
-test_skip_() {
-	SHARNESS_TEST_NB=$((SHARNESS_TEST_NB + 1))
-	to_skip=
-	for skp in $SKIP_TESTS; do
-		# shellcheck disable=SC2254
-		case $this_test.$SHARNESS_TEST_NB in
-		$skp)
-			to_skip=t
-			break
-		esac
-	done
-	if test -z "$to_skip" && test -n "$test_prereq" && ! test_have_prereq "$test_prereq"; then
-		to_skip=t
-	fi
-	case "$to_skip" in
-	t)
-		of_prereq=
-		if test "$missing_prereq" != "$test_prereq"; then
-			of_prereq=" of $test_prereq"
-		fi
-
-		say_color skip >&3 "skipping test: $*"
-		say_color skip "ok $SHARNESS_TEST_NB # skip $1 (missing $missing_prereq${of_prereq})"
-		: true
-		;;
-	*)
-		false
-		;;
-	esac
-}
-
-remove_trash_() {
-	test -d "$remove_trash" && (
-		cd "$(dirname "$remove_trash")" &&
-			rm -rf "$(basename "$remove_trash")"
-	)
-}
-
-# Public: Run test commands and expect them to succeed.
-#
-# When the test passed, an "ok" message is printed and the number of successful
-# tests is incremented. When it failed, a "not ok" message is printed and the
-# number of failed tests is incremented.
-#
-# With --immediate, exit test immediately upon the first failed test.
-#
-# Usually takes two arguments:
-# $1 - Test description
-# $2 - Commands to be executed.
-#
-# With three arguments, the first will be taken to be a prerequisite:
-# $1 - Comma-separated list of test prerequisites. The test will be skipped if
-#      not all of the given prerequisites are set. To negate a prerequisite,
-#      put a "!" in front of it.
-# $2 - Test description
-# $3 - Commands to be executed.
-#
-# Examples
-#
-#   test_expect_success \
-#       'git-write-tree should be able to write an empty tree.' \
-#       'tree=$(git-write-tree)'
-#
-#   # Test depending on one prerequisite.
-#   test_expect_success TTY 'git --paginate rev-list uses a pager' \
-#       ' ... '
-#
-#   # Multiple prerequisites are separated by a comma.
-#   test_expect_success PERL,PYTHON 'yo dawg' \
-#       ' test $(perl -E 'print eval "1 +" . qx[python -c "print 2"]') == "4" '
-#
-# Returns nothing.
-test_expect_success() {
-	test "$#" = 3 && { test_prereq=$1; shift; } || test_prereq=
-	test "$#" = 2 || error "bug in the test script: not 2 or 3 parameters to test_expect_success"
-	export test_prereq
-	if ! test_skip_ "$@"; then
-		say >&3 "expecting success: $2"
-		if test_run_ "$2"; then
-			test_ok_ "$1"
-		else
-			test_failure_ "$@"
-		fi
-	fi
-	echo >&3 ""
-}
-
-# Public: Run test commands and expect them to fail. Used to demonstrate a known
-# breakage.
-#
-# This is NOT the opposite of test_expect_success, but rather used to mark a
-# test that demonstrates a known breakage.
-#
-# When the test passed, an "ok" message is printed and the number of fixed tests
-# is incremented. When it failed, a "not ok" message is printed and the number
-# of tests still broken is incremented.
-#
-# Failures from these tests won't cause --immediate to stop.
-#
-# Usually takes two arguments:
-# $1 - Test description
-# $2 - Commands to be executed.
-#
-# With three arguments, the first will be taken to be a prerequisite:
-# $1 - Comma-separated list of test prerequisites. The test will be skipped if
-#      not all of the given prerequisites are set. To negate a prerequisite,
-#      put a "!" in front of it.
-# $2 - Test description
-# $3 - Commands to be executed.
-#
-# Returns nothing.
-test_expect_failure() {
-	test "$#" = 3 && { test_prereq=$1; shift; } || test_prereq=
-	test "$#" = 2 || error "bug in the test script: not 2 or 3 parameters to test_expect_failure"
-	export test_prereq
-	if ! test_skip_ "$@"; then
-		say >&3 "checking known breakage: $2"
-		if test_run_ "$2" expecting_failure; then
-			test_known_broken_ok_ "$1"
-		else
-			test_known_broken_failure_ "$1"
-		fi
-	fi
-	echo >&3 ""
-}
-
-# Public: Run test commands and expect anything from them. Used when a
-# test is not stable or not finished for some reason.
-#
-# When the test passed, an "ok" message is printed, but the number of
-# fixed tests is not incremented.
-#
-# When it failed, a "not ok ... # TODO known breakage" message is
-# printed, and the number of tests still broken is incremented.
-#
-# Failures from these tests won't cause --immediate to stop.
-#
-# Usually takes two arguments:
-# $1 - Test description
-# $2 - Commands to be executed.
-#
-# With three arguments, the first will be taken to be a prerequisite:
-# $1 - Comma-separated list of test prerequisites. The test will be skipped if
-#      not all of the given prerequisites are set. To negate a prerequisite,
-#      put a "!" in front of it.
-# $2 - Test description
-# $3 - Commands to be executed.
-#
-# Returns nothing.
-test_expect_unstable() {
-	test "$#" = 3 && { test_prereq=$1; shift; } || test_prereq=
-	test "$#" = 2 || error "bug in the test script: not 2 or 3 parameters to test_expect_unstable"
-	export test_prereq
-	if ! test_skip_ "$@"; then
-		say >&3 "checking unstable test: $2"
-		if test_run_ "$2" unstable; then
-			test_ok_ "$1"
-		else
-			test_known_broken_failure_ "$1"
-		fi
-	fi
-	echo >&3 ""
-}
-
-# Public: Summarize test results and exit with an appropriate error code.
-#
-# Must be called at the end of each test script.
-#
-# Can also be used to stop tests early and skip all remaining tests. For this,
-# set skip_all to a string explaining why the tests were skipped before calling
-# test_done.
-#
-# Examples
-#
-#   # Each test script must call test_done at the end.
-#   test_done
-#
-#   # Skip all remaining tests if prerequisite is not set.
-#   if ! test_have_prereq PERL; then
-#       skip_all='skipping perl interface tests, perl not available'
-#       test_done
-#   fi
-#
-# Returns 0 if all tests passed or 1 if there was a failure.
-# shellcheck disable=SC2154,SC2034
-test_done() {
-	EXIT_OK=t
-
-	if test -z "$HARNESS_ACTIVE"; then
-		test_results_dir="$SHARNESS_TEST_OUTDIR/test-results"
-		mkdir -p "$test_results_dir"
-		test_results_path="$test_results_dir/$this_test.$$.counts"
-
-		cat >>"$test_results_path" <<-EOF
-		total $SHARNESS_TEST_NB
-		success $test_success
-		fixed $test_fixed
-		broken $test_broken
-		failed $test_failure
-
-		EOF
-	fi
-
-	if test "$test_fixed" != 0; then
-		say_color error "# $test_fixed known breakage(s) vanished; please update test(s)"
-	fi
-	if test "$test_broken" != 0; then
-		say_color warn "# still have $test_broken known breakage(s)"
-	fi
-	if test "$test_broken" != 0 || test "$test_fixed" != 0; then
-		test_remaining=$((SHARNESS_TEST_NB - test_broken - test_fixed))
-		msg="remaining $test_remaining test(s)"
-	else
-		test_remaining=$SHARNESS_TEST_NB
-		msg="$SHARNESS_TEST_NB test(s)"
-	fi
-
-	case "$test_failure" in
-	0)
-		# Maybe print SKIP message
-		check_skip_all_
-		if test "$test_remaining" -gt 0; then
-			say_color pass "# passed all $msg"
-		fi
-		say "1..$SHARNESS_TEST_NB$skip_all"
-
-		test_eval_ "$final_cleanup"
-
-		remove_trash_
-
-		exit 0 ;;
-
-	*)
-		say_color error "# failed $test_failure among $msg"
-		say "1..$SHARNESS_TEST_NB"
-
-		exit 1 ;;
-
-	esac
-}
-
-: "${SHARNESS_BUILD_DIRECTORY:="$SHARNESS_TEST_DIRECTORY/.."}"
-# Public: Build directory that will be added to PATH. By default, it is set to
-# the parent directory of SHARNESS_TEST_DIRECTORY.
-export SHARNESS_BUILD_DIRECTORY
-PATH="$SHARNESS_BUILD_DIRECTORY:$PATH"
-export PATH
-
-# Public: Path to test script currently executed.
-SHARNESS_TEST_FILE="$0"
-export SHARNESS_TEST_FILE
-
-# Prepare test area.
-SHARNESS_TRASH_DIRECTORY="trash directory.$(basename "$SHARNESS_TEST_FILE" ".$SHARNESS_TEST_EXTENSION")"
-test -n "$root" && SHARNESS_TRASH_DIRECTORY="$root/$SHARNESS_TRASH_DIRECTORY"
-case "$SHARNESS_TRASH_DIRECTORY" in
-/*) ;; # absolute path is good
- *) SHARNESS_TRASH_DIRECTORY="$SHARNESS_TEST_OUTDIR/$SHARNESS_TRASH_DIRECTORY" ;;
-esac
-test "$debug" = "t" || remove_trash="$SHARNESS_TRASH_DIRECTORY"
-rm -rf "$SHARNESS_TRASH_DIRECTORY" || {
-	EXIT_OK=t
-	echo >&5 "FATAL: Cannot prepare test area"
-	exit 1
-}
-
-
-#
-#  Load any extensions in $testdir/sharness.d/*.sh
-#
-if test -d "${SHARNESS_TEST_DIRECTORY}/sharness.d"
-then
-	for file in "${SHARNESS_TEST_DIRECTORY}"/sharness.d/*.sh
-	do
-		# Ensure glob was not an empty match:
-		test -e "${file}" || break
-
-		if test -n "$debug"
-		then
-			echo >&5 "sharness: loading extensions from ${file}"
-		fi
-		# shellcheck disable=SC1090
-		. "${file}"
-		if test $? != 0
-		then
-			echo >&5 "sharness: Error loading ${file}. Aborting."
-			exit 1
-		fi
-	done
-fi
-
-# Public: Empty trash directory, the test area, provided for each test. The HOME
-# variable is set to that directory too.
-export SHARNESS_TRASH_DIRECTORY
-
-HOME="$SHARNESS_TRASH_DIRECTORY"
-export HOME
-
-# shellcheck disable=SC3028
-if [ "$OSTYPE" = msys ]; then
-	USERPROFILE="$SHARNESS_TRASH_DIRECTORY"
-	export USERPROFILE
-fi
-
-mkdir -p "$SHARNESS_TRASH_DIRECTORY" || exit 1
-# Use -P to resolve symlinks in our working directory so that the cwd
-# in subprocesses like git equals our $PWD (for pathname comparisons).
-cd -P "$SHARNESS_TRASH_DIRECTORY" || exit 1
-
-check_skip_all_() {
-	if test -n "$skip_all" && test $SHARNESS_TEST_NB -gt 0; then
-		error "Can't use skip_all after running some tests"
-	fi
-	[ -z "$skip_all" ] || skip_all=" # SKIP $skip_all"
-}
-
-this_test=${SHARNESS_TEST_FILE##*/}
-this_test=${this_test%".$SHARNESS_TEST_EXTENSION"}
-for skp in $SKIP_TESTS; do
-	# shellcheck disable=SC2254
-	case "$this_test" in
-	$skp)
-		say_color info >&3 "skipping test $this_test altogether"
-		skip_all="skip all tests in $this_test"
-		test_done
-	esac
-done
-
-test -n "$TEST_LONG" && test_set_prereq EXPENSIVE
-test -n "$TEST_INTERACTIVE" && test_set_prereq INTERACTIVE
-
-# Make sure this script ends with code 0
-:
-
-# vi: set ts=4 sw=4 noet :

t/test-lib.sh

@@ -1,136 +0,0 @@
-#!/bin/bash
-
-: "${SHARNESS_TEST_SRCDIR:=$(cd "$(dirname "${BASH_SOURCE-$0}")" && pwd)}"
-
-if [ -z "$SHARNESS" ] ; then
-	for d in \
-		"$SHARNESS_TEST_SRCDIR" \
-		"$HOME/share/sharness" \
-		"/usr/local/share/sharness" \
-		"/usr/share/sharness"
-	do
-		f="$d/sharness.sh"
-		if [ -f "$f" ] ; then
-			SHARNESS="$f"
-		fi
-	done
-fi
-if [ -z "$SHARNESS" ] || [ ! -f "$SHARNESS" ] ; then
-	echo "sharness.sh not found" >&2
-	exit 1
-fi
-
-# Prevent sharness from adding the source directory to PATH
-# since the scripts use unversioned python for their shebang
-# but tests should run under the python with mercurial support
-# so create an empty directory and strip it from PATH afterwards
-SHARNESS_BUILD_DIRECTORY="$(mktemp -d)"
-. "$SHARNESS"
-export PATH="${PATH#*:}"
-rmdir "$SHARNESS_BUILD_DIRECTORY"
-
-GIT_AUTHOR_EMAIL=author@example.com
-GIT_AUTHOR_NAME='A U Thor'
-GIT_COMMITTER_EMAIL=committer@example.com
-GIT_COMMITTER_NAME='C O Mitter'
-export GIT_AUTHOR_EMAIL GIT_AUTHOR_NAME
-export GIT_COMMITTER_EMAIL GIT_COMMITTER_NAME
-
-# maintain backwards compatible default
-# (as used in remote helper)
-git config --global init.defaultBranch master
-git config --global protocol.file.allow always
-
-unset XDG_CONFIG_HOME
-
-test_set_prereq() {
-	satisfied_prereq="$satisfied_prereq$1 "
-}
-satisfied_prereq=" "
-
-case "$(uname -s)" in
-MSYS*|MINGW*)
-	test_set_prereq WIN
-	export TEST_CMP='diff --strip-trailing-cr -u'
-	;;
-esac
-
-test_cmp() {
-	${TEST_CMP:-diff -u} "$@"
-}
-
-test_when_finished() {
-	test_cleanup="{ $*
-		} && (exit \"\$eval_ret\"); eval_ret=\$?; $test_cleanup"
-}
-
-test_expect_code() {
-	want_code=$1
-	shift
-	"$@"
-	exit_code=$?
-	if test "$exit_code" = "$want_code"; then
-		return 0
-	fi
-
-	echo >&2 "test_expect_code: command exited with $exit_code, we wanted $want_code $*"
-	return 1
-}
-
-test_have_prereq() {
-	prerequisite=$1
-
-	case "$prerequisite" in
-	!*)
-		negative_prereq=t
-		prerequisite=${prerequisite#!}
-		;;
-	*)
-		negative_prereq=
-	esac
-
-	case "$satisfied_prereq" in
-	*" $prerequisite "*)
-		satisfied_this_prereq=t
-		;;
-	*)
-		satisfied_this_prereq=
-	esac
-
-	case "$satisfied_this_prereq,$negative_prereq" in
-	t,|,t)
-		return 0
-		;;
-	esac
-
-	return 1
-}
-
-if [ -z "$TEST_INSTALLED_SCRIPTS" ] ; then
-	if [ -n "$PYTHON" ] && "$PYTHON" -c 'import mercurial' 2> /dev/null ; then
-		: Use chosen Python version
-	elif python3 -c 'import mercurial' 2> /dev/null ; then
-		PYTHON=python3
-	elif python2 -c 'import mercurial' 2> /dev/null ; then
-		PYTHON=python2
-	elif python -c 'import mercurial' 2> /dev/null ; then
-		PYTHON=python
-	fi
-	if [ -n "$PYTHON" ] ; then
-		test_set_prereq PYTHON
-
-		# Change shebang on a copy of scripts to chosen Python version
-		TEST_BIN="$SHARNESS_TRASH_DIRECTORY/bin"
-		mkdir -p "$TEST_BIN"
-		for s in git-remote-hg git-hg-helper ; do
-			printf "%s\n" "#!/usr/bin/env $PYTHON" > "$TEST_BIN/$s"
-			tail -n +2 "$SHARNESS_TEST_DIRECTORY/../$s" >> "$TEST_BIN/$s"
-			chmod u+x "$TEST_BIN/$s"
-		done
-		export PATH="$TEST_BIN${PATH:+:$PATH}"
-		unset TEST_BIN
-	fi
-else
-	# The build/install process ensures Python is available
-	test_set_prereq PYTHON
-fi

test/Makefile

@@ -1,9 +1,9 @@
 RM ?= rm -f
 
-T = main.t main-push.t bidi.t helper.t
+T = $(wildcard *.t)
-SHARNESS_TEST_DIRECTORY := $(CURDIR)
+TEST_DIRECTORY := $(CURDIR)
 
-export SHARNESS_TEST_DIRECTORY
+export TEST_DIRECTORY
 
 all: test
 
@@ -11,7 +11,7 @@ test: $(T)
 	$(MAKE) clean
 
 $(T):
-	./$@ $(TEST_OPTS)
+	$(SHELL) $@ $(TEST_OPTS)
 
 clean:
 	$(RM) -r 'trash directory'.* test-results

test/bidi.t

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/bin/sh
 #
 # Copyright (c) 2012 Felipe Contreras
 #
@@ -8,7 +8,20 @@
 
 test_description='Test bidirectionality of remote-hg'
 
-. "$(dirname "$0")"/test-lib.sh
+test -n "$TEST_DIRECTORY" || TEST_DIRECTORY=$(dirname $0)/
+. "$TEST_DIRECTORY"/test-lib.sh
+
+if ! test_have_prereq PYTHON
+then
+	skip_all='skipping remote-hg tests; python not available'
+	test_done
+fi
+
+if ! python2 -c 'import mercurial' > /dev/null 2>&1
+then
+	skip_all='skipping remote-hg tests; mercurial not available'
+	test_done
+fi
 
 # clone to a git repo
 git_clone () {
@@ -38,7 +51,7 @@ hg_push () {
 }
 
 hg_log () {
-	hg -R $1 log --debug
+	hg -R $1 log --graph --debug
 }
 
 setup () {
@@ -191,9 +204,8 @@ test_expect_success 'hg branch' '
 	: Back to the common revision &&
 	(cd hgrepo && hg checkout default) &&
 
-	# fetch does not affect phase, but pushing now does
+	hg_log hgrepo > expected &&
-	hg_log hgrepo | grep -v phase > expected &&
+	hg_log hgrepo2 > actual &&
-	hg_log hgrepo2 | grep -v phase > actual &&
 
 	test_cmp expected actual
 '
@@ -220,47 +232,7 @@ test_expect_success 'hg tags' '
 	) &&
 
 	hg_push hgrepo gitrepo &&
-	# pushing a fetched tag is a problem ...
+	hg_clone gitrepo hgrepo2 &&
-	{ hg_clone gitrepo hgrepo2 || true ; } &&
-
-	# fetch does not affect phase, but pushing now does
-	hg_log hgrepo | grep -v phase > expected &&
-	hg_log hgrepo2 | grep -v phase > actual &&
-
-	test_cmp expected actual
-'
-
-test_expect_success 'test timezones' '
-	test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-	(
-	git init -q gitrepo &&
-	cd gitrepo &&
-
-	echo alpha > alpha &&
-	git add alpha &&
-	git commit -m "add alpha" --date="2007-01-01 00:00:00 +0000" &&
-
-	echo beta > beta &&
-	git add beta &&
-	git commit -m "add beta" --date="2007-01-01 00:00:00 +0100" &&
-
-	echo gamma > gamma &&
-	git add gamma &&
-	git commit -m "add gamma" --date="2007-01-01 00:00:00 -0100" &&
-
-	echo delta > delta &&
-	git add delta &&
-	git commit -m "add delta" --date="2007-01-01 00:00:00 +0130" &&
-
-	echo epsilon > epsilon &&
-	git add epsilon &&
-	git commit -m "add epsilon" --date="2007-01-01 00:00:00 -0130"
-	) &&
-
-	hg_clone gitrepo hgrepo &&
-	git_clone hgrepo gitrepo2 &&
-	hg_clone gitrepo2 hgrepo2 &&
 
 	hg_log hgrepo > expected &&
 	hg_log hgrepo2 > actual &&

test/hg-git.t

@@ -0,0 +1,558 @@
+#!/bin/sh
+#
+# Copyright (c) 2012 Felipe Contreras
+#
+# Base commands from hg-git tests:
+# https://bitbucket.org/durin42/hg-git/src
+#
+
+test_description='Test remote-hg output compared to hg-git'
+
+test -n "$TEST_DIRECTORY" || TEST_DIRECTORY=$(dirname $0)/
+. "$TEST_DIRECTORY"/test-lib.sh
+
+if ! test_have_prereq PYTHON
+then
+	skip_all='skipping remote-hg tests; python not available'
+	test_done
+fi
+
+if ! python2 -c 'import mercurial' > /dev/null 2>&1
+then
+	skip_all='skipping remote-hg tests; mercurial not available'
+	test_done
+fi
+
+if python2 -c 'import hggit' > /dev/null 2>&1
+then
+	hggit=hggit
+elif python2 -c 'import hgext.git' > /dev/null 2>&1
+then
+	hggit=hgext.git
+else
+	skip_all='skipping remote-hg tests; hg-git not available'
+	test_done
+fi
+
+hg_version=$(python2 -c 'from mercurial import util; print util.version()')
+
+echo "hg_version: $hg_version"
+
+case $hg_version in
+3.0*+*)
+	skip_all='skipping remote-hg tests; unsuported version of hg by hg-git'
+	test_done
+	;;
+esac
+
+# clone to a git repo with git
+git_clone_git () {
+	git clone -q "hg::$1" $2 &&
+	(cd $2 && git checkout master && git branch -D default)
+}
+
+# clone to an hg repo with git
+hg_clone_git () {
+	(
+	hg init $2 &&
+	hg -R $2 bookmark -i master &&
+	cd $1 &&
+	git push -q "hg::../$2" 'refs/tags/*:refs/tags/*' 'refs/heads/*:refs/heads/*'
+	) &&
+
+	(cd $2 && hg -q update)
+}
+
+# clone to a git repo with hg
+git_clone_hg () {
+	(
+	git init -q $2 &&
+	cd $1 &&
+	hg bookmark -i -f -r tip master &&
+	hg -q push -r master ../$2 || true
+	)
+}
+
+# clone to an hg repo with hg
+hg_clone_hg () {
+	hg -q clone $1 $2
+}
+
+# push an hg repo with git
+hg_push_git () {
+	(
+	cd $2
+	git checkout -q -b tmp &&
+	git fetch -q "hg::../$1" 'refs/tags/*:refs/tags/*' 'refs/heads/*:refs/heads/*' &&
+	git branch -D default &&
+	git checkout -q @{-1} &&
+	git branch -q -D tmp 2> /dev/null || true
+	)
+}
+
+# push an hg git repo with hg
+hg_push_hg () {
+	(
+	cd $1 &&
+	hg -q push ../$2 || true
+	)
+}
+
+hg_log () {
+	hg -R $1 log --graph --debug > log &&
+	grep -v 'tag: *default/' log
+}
+
+git_log () {
+	git --git-dir=$1/.git fast-export --branches
+}
+
+setup () {
+	cat > "$HOME"/.hgrc <<-EOF &&
+	[ui]
+	username = A U Thor <author@example.com>
+	[defaults]
+	backout = -d "0 0"
+	commit = -d "0 0"
+	debugrawcommit = -d "0 0"
+	tag = -d "0 0"
+	[extensions]
+	hgext.bookmarks =
+	$hggit =
+	graphlog =
+	EOF
+	git config --global receive.denycurrentbranch warn
+	git config --global remote-hg.hg-git-compat true
+	git config --global remote-hg.track-branches false
+
+	HGEDITOR=true
+	HGMERGE=true
+
+	GIT_AUTHOR_DATE="2007-01-01 00:00:00 +0230"
+	GIT_COMMITTER_DATE="$GIT_AUTHOR_DATE"
+	export HGEDITOR HGMERGE GIT_AUTHOR_DATE GIT_COMMITTER_DATE
+}
+
+setup
+
+test_expect_success 'executable bit' '
+	test_when_finished "rm -rf gitrepo* hgrepo*" &&
+
+	(
+	git init -q gitrepo &&
+	cd gitrepo &&
+	echo alpha > alpha &&
+	chmod 0644 alpha &&
+	git add alpha &&
+	git commit -m "add alpha" &&
+	chmod 0755 alpha &&
+	git add alpha &&
+	git commit -m "set executable bit" &&
+	chmod 0644 alpha &&
+	git add alpha &&
+	git commit -m "clear executable bit"
+	) &&
+
+	for x in hg git
+	do
+		(
+		hg_clone_$x gitrepo hgrepo-$x &&
+		cd hgrepo-$x &&
+		hg_log . &&
+		hg manifest -r 1 -v &&
+		hg manifest -v
+		) > "output-$x" &&
+
+		git_clone_$x hgrepo-$x gitrepo2-$x &&
+		git_log gitrepo2-$x > "log-$x"
+	done &&
+
+	test_cmp output-hg output-git &&
+	test_cmp log-hg log-git
+'
+
+test_expect_success 'symlink' '
+	test_when_finished "rm -rf gitrepo* hgrepo*" &&
+
+	(
+	git init -q gitrepo &&
+	cd gitrepo &&
+	echo alpha > alpha &&
+	git add alpha &&
+	git commit -m "add alpha" &&
+	ln -s alpha beta &&
+	git add beta &&
+	git commit -m "add beta"
+	) &&
+
+	for x in hg git
+	do
+		(
+		hg_clone_$x gitrepo hgrepo-$x &&
+		cd hgrepo-$x &&
+		hg_log . &&
+		hg manifest -v
+		) > "output-$x" &&
+
+		git_clone_$x hgrepo-$x gitrepo2-$x &&
+		git_log gitrepo2-$x > "log-$x"
+	done &&
+
+	test_cmp output-hg output-git &&
+	test_cmp log-hg log-git
+'
+
+test_expect_success 'merge conflict 1' '
+	test_when_finished "rm -rf gitrepo* hgrepo*" &&
+
+	(
+	hg init hgrepo1 &&
+	cd hgrepo1 &&
+	echo A > afile &&
+	hg add afile &&
+	hg ci -m "origin" &&
+
+	echo B > afile &&
+	hg ci -m "A->B" &&
+
+	hg up -r0 &&
+	echo C > afile &&
+	hg ci -m "A->C" &&
+
+	hg merge -r1 &&
+	echo C > afile &&
+	hg resolve -m afile &&
+	hg ci -m "merge to C"
+	) &&
+
+	for x in hg git
+	do
+		git_clone_$x hgrepo1 gitrepo-$x &&
+		hg_clone_$x gitrepo-$x hgrepo2-$x &&
+		hg_log hgrepo2-$x > "hg-log-$x" &&
+		git_log gitrepo-$x > "git-log-$x"
+	done &&
+
+	test_cmp hg-log-hg hg-log-git &&
+	test_cmp git-log-hg git-log-git
+'
+
+test_expect_success 'merge conflict 2' '
+	test_when_finished "rm -rf gitrepo* hgrepo*" &&
+
+	(
+	hg init hgrepo1 &&
+	cd hgrepo1 &&
+	echo A > afile &&
+	hg add afile &&
+	hg ci -m "origin" &&
+
+	echo B > afile &&
+	hg ci -m "A->B" &&
+
+	hg up -r0 &&
+	echo C > afile &&
+	hg ci -m "A->C" &&
+
+	hg merge -r1 || true &&
+	echo B > afile &&
+	hg resolve -m afile &&
+	hg ci -m "merge to B"
+	) &&
+
+	for x in hg git
+	do
+		git_clone_$x hgrepo1 gitrepo-$x &&
+		hg_clone_$x gitrepo-$x hgrepo2-$x &&
+		hg_log hgrepo2-$x > "hg-log-$x" &&
+		git_log gitrepo-$x > "git-log-$x"
+	done &&
+
+	test_cmp hg-log-hg hg-log-git &&
+	test_cmp git-log-hg git-log-git
+'
+
+test_expect_success 'converged merge' '
+	test_when_finished "rm -rf gitrepo* hgrepo*" &&
+
+	(
+	hg init hgrepo1 &&
+	cd hgrepo1 &&
+	echo A > afile &&
+	hg add afile &&
+	hg ci -m "origin" &&
+
+	echo B > afile &&
+	hg ci -m "A->B" &&
+
+	echo C > afile &&
+	hg ci -m "B->C" &&
+
+	hg up -r0 &&
+	echo C > afile &&
+	hg ci -m "A->C" &&
+
+	hg merge -r2 || true &&
+	hg ci -m "merge"
+	) &&
+
+	for x in hg git
+	do
+		git_clone_$x hgrepo1 gitrepo-$x &&
+		hg_clone_$x gitrepo-$x hgrepo2-$x &&
+		hg_log hgrepo2-$x > "hg-log-$x" &&
+		git_log gitrepo-$x > "git-log-$x"
+	done &&
+
+	test_cmp hg-log-hg hg-log-git &&
+	test_cmp git-log-hg git-log-git
+'
+
+test_expect_success 'encoding' '
+	test_when_finished "rm -rf gitrepo* hgrepo*" &&
+
+	(
+	git init -q gitrepo &&
+	cd gitrepo &&
+
+	echo alpha > alpha &&
+	git add alpha &&
+	git commit -m "add älphà" &&
+
+	GIT_AUTHOR_NAME="tést èncödîng" &&
+	export GIT_AUTHOR_NAME &&
+	echo beta > beta &&
+	git add beta &&
+	git commit -m "add beta" &&
+
+	echo gamma > gamma &&
+	git add gamma &&
+	git commit -m "add gämmâ" &&
+
+	: TODO git config i18n.commitencoding latin-1 &&
+	echo delta > delta &&
+	git add delta &&
+	git commit -m "add déltà"
+	) &&
+
+	for x in hg git
+	do
+		hg_clone_$x gitrepo hgrepo-$x &&
+		git_clone_$x hgrepo-$x gitrepo2-$x &&
+
+		HGENCODING=utf-8 hg_log hgrepo-$x > "hg-log-$x" &&
+		git_log gitrepo2-$x > "git-log-$x"
+	done &&
+
+	test_cmp hg-log-hg hg-log-git &&
+	test_cmp git-log-hg git-log-git
+'
+
+test_expect_success 'file removal' '
+	test_when_finished "rm -rf gitrepo* hgrepo*" &&
+
+	(
+	git init -q gitrepo &&
+	cd gitrepo &&
+	echo alpha > alpha &&
+	git add alpha &&
+	git commit -m "add alpha" &&
+	echo beta > beta &&
+	git add beta &&
+	git commit -m "add beta"
+	mkdir foo &&
+	echo blah > foo/bar &&
+	git add foo &&
+	git commit -m "add foo" &&
+	git rm alpha &&
+	git commit -m "remove alpha" &&
+	git rm foo/bar &&
+	git commit -m "remove foo/bar"
+	) &&
+
+	for x in hg git
+	do
+		(
+		hg_clone_$x gitrepo hgrepo-$x &&
+		cd hgrepo-$x &&
+		hg_log . &&
+		hg manifest -r 3 &&
+		hg manifest
+		) > "output-$x" &&
+
+		git_clone_$x hgrepo-$x gitrepo2-$x &&
+		git_log gitrepo2-$x > "log-$x"
+	done &&
+
+	test_cmp output-hg output-git &&
+	test_cmp log-hg log-git
+'
+
+test_expect_success 'git tags' '
+	test_when_finished "rm -rf gitrepo* hgrepo*" &&
+
+	(
+	git init -q gitrepo &&
+	cd gitrepo &&
+	git config receive.denyCurrentBranch ignore &&
+	echo alpha > alpha &&
+	git add alpha &&
+	git commit -m "add alpha" &&
+	git tag alpha &&
+
+	echo beta > beta &&
+	git add beta &&
+	git commit -m "add beta" &&
+	git tag -a -m "added tag beta" beta
+	) &&
+
+	for x in hg git
+	do
+		hg_clone_$x gitrepo hgrepo-$x &&
+		hg_log hgrepo-$x > "log-$x"
+	done &&
+
+	test_cmp log-hg log-git
+'
+
+test_expect_success 'hg author' '
+	test_when_finished "rm -rf gitrepo* hgrepo*" &&
+
+	for x in hg git
+	do
+		(
+		git init -q gitrepo-$x &&
+		cd gitrepo-$x &&
+
+		echo alpha > alpha &&
+		git add alpha &&
+		git commit -m "add alpha" &&
+		git checkout -q -b not-master
+		) &&
+
+		(
+		hg_clone_$x gitrepo-$x hgrepo-$x &&
+		cd hgrepo-$x &&
+
+		hg co master &&
+		echo beta > beta &&
+		hg add beta &&
+		hg commit -u "test" -m "add beta" &&
+
+		echo gamma >> beta &&
+		hg commit -u "test <test@example.com> (comment)" -m "modify beta" &&
+
+		echo gamma > gamma &&
+		hg add gamma &&
+		hg commit -u "<test@example.com>" -m "add gamma" &&
+
+		echo delta > delta &&
+		hg add delta &&
+		hg commit -u "name<test@example.com>" -m "add delta" &&
+
+		echo epsilon > epsilon &&
+		hg add epsilon &&
+		hg commit -u "name <test@example.com" -m "add epsilon" &&
+
+		echo zeta > zeta &&
+		hg add zeta &&
+		hg commit -u " test " -m "add zeta" &&
+
+		echo eta > eta &&
+		hg add eta &&
+		hg commit -u "test < test@example.com >" -m "add eta" &&
+
+		echo theta > theta &&
+		hg add theta &&
+		hg commit -u "test >test@example.com>" -m "add theta" &&
+
+		echo iota > iota &&
+		hg add iota &&
+		hg commit -u "test <test <at> example <dot> com>" -m "add iota"
+		) &&
+
+		hg_push_$x hgrepo-$x gitrepo-$x &&
+		hg_clone_$x gitrepo-$x hgrepo2-$x &&
+
+		hg_log hgrepo2-$x > "hg-log-$x" &&
+		git_log gitrepo-$x > "git-log-$x"
+	done &&
+
+	test_cmp hg-log-hg hg-log-git &&
+	test_cmp git-log-hg git-log-git
+'
+
+test_expect_success 'hg branch' '
+	test_when_finished "rm -rf gitrepo* hgrepo*" &&
+
+	for x in hg git
+	do
+		(
+		git init -q gitrepo-$x &&
+		cd gitrepo-$x &&
+
+		echo alpha > alpha &&
+		git add alpha &&
+		git commit -q -m "add alpha" &&
+		git checkout -q -b not-master
+		) &&
+
+		(
+		hg_clone_$x gitrepo-$x hgrepo-$x &&
+
+		cd hgrepo-$x &&
+		hg -q co master &&
+		hg mv alpha beta &&
+		hg -q commit -m "rename alpha to beta" &&
+		hg branch gamma | grep -v "permanent and global" &&
+		hg -q commit -m "started branch gamma"
+		) &&
+
+		hg_push_$x hgrepo-$x gitrepo-$x &&
+		hg_clone_$x gitrepo-$x hgrepo2-$x &&
+
+		hg_log hgrepo2-$x > "hg-log-$x" &&
+		git_log gitrepo-$x > "git-log-$x"
+	done &&
+
+	test_cmp hg-log-hg hg-log-git &&
+	test_cmp git-log-hg git-log-git
+'
+
+test_expect_success 'hg tags' '
+	test_when_finished "rm -rf gitrepo* hgrepo*" &&
+
+	for x in hg git
+	do
+		(
+		git init -q gitrepo-$x &&
+		cd gitrepo-$x &&
+
+		echo alpha > alpha &&
+		git add alpha &&
+		git commit -m "add alpha" &&
+		git checkout -q -b not-master
+		) &&
+
+		(
+		hg_clone_$x gitrepo-$x hgrepo-$x &&
+
+		cd hgrepo-$x &&
+		hg co master &&
+		hg tag alpha
+		) &&
+
+		hg_push_$x hgrepo-$x gitrepo-$x &&
+		hg_clone_$x gitrepo-$x hgrepo2-$x &&
+
+		(
+		git --git-dir=gitrepo-$x/.git tag -l &&
+		hg_log hgrepo2-$x &&
+		cat hgrepo2-$x/.hgtags
+		) > "output-$x"
+	done &&
+
+	test_cmp output-hg output-git
+'
+
+test_done

test/main.t

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/bin/sh
 #
 # Copyright (c) 2012 Felipe Contreras
 #
@@ -8,15 +8,19 @@
 
 test_description='Test remote-hg'
 
-. "$(dirname "$0")"/test-lib.sh
+test -n "$TEST_DIRECTORY" || TEST_DIRECTORY=$(dirname $0)/
+. "$TEST_DIRECTORY"/test-lib.sh
 
-if test "$CAPABILITY_PUSH" = "t"
+if ! test_have_prereq PYTHON
 then
-	git config --global remote-hg.capability-push true
+	skip_all='skipping remote-hg tests; python not available'
-	git config --global remote-hg.push-updates-notes true
+	test_done
-	git config --global remote-hg.fast-export-options '-C -C -M'
+fi
-else
+
-	git config --global remote-hg.capability-push false
+if ! python2 -c 'import mercurial' > /dev/null 2>&1
+then
+	skip_all='skipping remote-hg tests; mercurial not available'
+	test_done
 fi
 
 check () {
@@ -77,20 +81,23 @@ check_push () {
 		'non-fast-forward')
 			grep "^ ! \[rejected\] *${branch} -> ${branch} (non-fast-forward)$" error || ref_ret=1
 			;;
+		'fetch-first')
+			grep "^ ! \[rejected\] *${branch} -> ${branch} (fetch first)$" error || ref_ret=1
+			;;
 		'forced-update')
 			grep "^ + [a-f0-9]*\.\.\.[a-f0-9]* *${branch} -> ${branch} (forced update)$" error || ref_ret=1
 			;;
 		'')
 			grep "^   [a-f0-9]*\.\.[a-f0-9]* *${branch} -> ${branch}$" error || ref_ret=1
 			;;
-		*)
-			echo "BUG: wrong kind '$kind'" && return 3
-			;;
 		esac
-		test $ref_ret -ne 0 && echo "match for '$branch' failed" && return 2
+		test $ref_ret -ne 0 && echo "match for '$branch' failed" && break
 	done
 
-	test $expected_ret -ne $ret && return 1
+	if test $expected_ret -ne $ret || test $ref_ret -ne 0
+	then
+		return 1
+	fi
 
 	return 0
 }
@@ -169,7 +176,7 @@ test_expect_success 'update bookmark' '
 	git checkout --quiet devel &&
 	echo devel > content &&
 	git commit -a -m devel &&
-	git push --quiet origin devel
+	git push --quiet
 	) &&
 
 	check_bookmark hgrepo devel devel
@@ -268,41 +275,6 @@ test_expect_success 'strip' '
 	test_cmp actual expected
 '
 
-test_expect_success 'dotfiles' '
-	test_when_finished "rm -rf hgrepo gitrepo" &&
-
-	(
-	hg init hgrepo &&
-	cd hgrepo &&
-
-	echo one >.git &&
-	echo ONE >.GIT &&
-	mkdir a && echo two > a/.gitmodules &&
-	hg add .git .GIT a/.gitmodules &&
-	hg commit -m zero
-	) &&
-
-	git clone "hg::hgrepo" gitrepo &&
-	test_cmp gitrepo/.git_ hgrepo/.git &&
-	test_cmp gitrepo/.GIT_ hgrepo/.GIT &&
-	test_cmp gitrepo/a/.gitmodules_ hgrepo/a/.gitmodules &&
-
-	(
-	cd gitrepo &&
-	echo three >.git_ &&
-	echo THREE >.GIT &&
-	echo four >a/.gitmodules_ &&
-	git add .git_ .GIT_ a/.gitmodules_ &&
-	git commit -m one &&
-	git push
-	) &&
-
-	hg -R hgrepo update &&
-	test_cmp gitrepo/.git_ hgrepo/.git &&
-	test_cmp gitrepo/.GIT_ hgrepo/.GIT &&
-	test_cmp gitrepo/a/.gitmodules_ hgrepo/a/.gitmodules
-'
-
 test_expect_success 'remote push with master bookmark' '
 	test_when_finished "rm -rf hgrepo gitrepo*" &&
 
@@ -470,7 +442,7 @@ test_expect_success 'remote update bookmark diverge' '
 	echo diverge > content &&
 	git commit -a -m diverge &&
 	check_push 1 <<-\EOF
-	diverge:non-fast-forward
+	diverge:fetch-first
 	EOF
 	) &&
 
@@ -495,56 +467,10 @@ test_expect_success 'remote new bookmark multiple branch head' '
 # cleanup previous stuff
 rm -rf hgrepo
 
-testcopyrenamedesc='push commits with copy and rename'
+test_expect_success 'fetch special filenames' '
-testcopyrename='
-	test_when_finished "rm -rf gitrepo hgrepo" &&
-
-	(
-	hg init hgrepo &&
-	cd hgrepo &&
-	echo zero > content &&
-	hg add content &&
-	hg commit -m zero
-	) &&
-
-	git clone "hg::hgrepo" gitrepo &&
-
-	(
-	cd gitrepo &&
-	cp content content-copy &&
-	# recent git-fast-export is (too) picky in recognizing copies
-	# although git-log is not as picky;
-	# since https://github.com/git/git/commit/8096e1d385660c159d9d47e69b2be63cf22e4f31
-	# a copy is only marked if source filed not modified as well
-	# (though destination file can be modified)
-	echo one >> content-copy &&
-	git add content content-copy &&
-	git commit -m copy &&
-	git mv content-copy content-moved
-	git commit -m moved &&
-	git push origin master
-	) &&
-
-	(
-	hg -R hgrepo update &&
-	test_cmp gitrepo/content hgrepo/content
-	test_cmp gitrepo/content-moved hgrepo/content-moved
-	cd hgrepo &&
-	test `hg log -f content-moved | grep -c changeset` -eq 3
-	)
-'
-
-if test "$CAPABILITY_PUSH" = "t"
-then
-test_expect_success "$testcopyrenamedesc" "$testcopyrename"
-else
-test_expect_failure "$testcopyrenamedesc" "$testcopyrename"
-fi
-
-test_expect_success !WIN 'fetch special filenames' '
 	test_when_finished "rm -rf hgrepo gitrepo && LC_ALL=C" &&
 
-	LC_ALL=en_US.UTF-8
+	LC_ALL=C.UTF-8
 	export LC_ALL
 
 	(
@@ -577,7 +503,7 @@ test_expect_success 'push special filenames' '
 
 	mkdir -p tmp && cd tmp &&
 
-	LC_ALL=en_US.UTF-8
+	LC_ALL=C.UTF-8
 	export LC_ALL
 
 	(
@@ -680,56 +606,29 @@ test_expect_success 'remote big push' '
 	(
 	cd gitrepo &&
 
-	if test "$CAPABILITY_PUSH" = "t"
+	check_push 1 --all <<-\EOF
-	then
+	master
-		# cap push handles refs one by one
+	good_bmark
-		# so it will still correctly report several ok
+	branches/good_branch
-		check_push 1 --all <<-\EOF
+	new_bmark:new
-		master
+	branches/new_branch:new
-		good_bmark
+	bad_bmark1:non-fast-forward
-		branches/good_branch
+	bad_bmark2:non-fast-forward
-		new_bmark:new
+	branches/bad_branch:non-fast-forward
-		branches/new_branch:new
+	EOF
-		bad_bmark1:non-fast-forward
-		bad_bmark2:non-fast-forward
-		branches/bad_branch:non-fast-forward
-		EOF
-	else
-		check_push 1 --all <<-\EOF
-		bad_bmark1:non-fast-forward
-		bad_bmark2:non-fast-forward
-		branches/bad_branch:non-fast-forward
-		EOF
-	fi
 	) &&
 
-	if test "$CAPABILITY_PUSH" = "t"
+	check_branch hgrepo default one &&
-	then
+	check_branch hgrepo good_branch "good branch" &&
-		# cap push handles refs one by one
+	check_branch hgrepo bad_branch "bad branch" &&
-		# so it will push all requested it can
+	check_branch hgrepo new_branch '' &&
-		check_branch hgrepo default six &&
+	check_bookmark hgrepo good_bmark one &&
-		check_branch hgrepo good_branch eight &&
+	check_bookmark hgrepo bad_bmark1 one &&
-		check_branch hgrepo bad_branch "bad branch" &&
+	check_bookmark hgrepo bad_bmark2 one &&
-		check_branch hgrepo new_branch ten &&
+	check_bookmark hgrepo new_bmark ''
-		check_bookmark hgrepo good_bmark three &&
-		check_bookmark hgrepo bad_bmark1 one &&
-		check_bookmark hgrepo bad_bmark2 one &&
-		check_bookmark hgrepo new_bmark six &&
-		check gitrepo origin/master two
-	else
-		check_branch hgrepo default one &&
-		check_branch hgrepo good_branch "good branch" &&
-		check_branch hgrepo bad_branch "bad branch" &&
-		check_branch hgrepo new_branch &&
-		check_bookmark hgrepo good_bmark one &&
-		check_bookmark hgrepo bad_bmark1 one &&
-		check_bookmark hgrepo bad_bmark2 one &&
-		check_bookmark hgrepo new_bmark &&
-		check gitrepo origin/master one
-	fi
 '
 
-test_expect_success 'remote big push non fast forward' '
+test_expect_success 'remote big push fetch first' '
 	test_when_finished "rm -rf hgrepo gitrepo*" &&
 
 	(
@@ -775,44 +674,25 @@ test_expect_success 'remote big push non fast forward' '
 	echo five > content &&
 	git commit -q -a -m five &&
 
-	if test "$CAPABILITY_PUSH" = "t"
+	check_push 1 --all <<-\EOF &&
-	then
+	master
-		check_push 1 --all <<-\EOF
+	good_bmark
-		master
+	bad_bmark:fetch-first
-		good_bmark
+	branches/bad_branch:festch-first
-		bad_bmark:non-fast-forward
+	EOF
-		branches/bad_branch:non-fast-forward
-		EOF
-	else
-		# cap export now only report error cases
-		check_push 1 --all <<-\EOF
-		bad_bmark:non-fast-forward
-		branches/bad_branch:non-fast-forward
-		EOF
-	fi &&
 
 	git fetch &&
 
-        if test "$CAPABILITY_PUSH" = "t"
+	check_push 1 --all <<-\EOF
-        then
+	master
-                # cap push handles refs one by one
+	good_bmark
-		# so it will already have pushed some above previously
+	bad_bmark:non-fast-forward
-		# (and master is a fake one that jumps around a bit)
+	branches/bad_branch:non-fast-forward
-		check_push 1 --all <<-\EOF
+	EOF
-		bad_bmark:non-fast-forward
-		branches/bad_branch:non-fast-forward
-		EOF
-	else
-		# cap export now only report error cases
-		check_push 1 --all <<-\EOF
-		bad_bmark:non-fast-forward
-		branches/bad_branch:non-fast-forward
-		EOF
-	fi
 	)
 '
 
-test_expect_success 'remote big push force' '
+test_expect_failure 'remote big push force' '
 	test_when_finished "rm -rf hgrepo gitrepo*" &&
 
 	setup_big_push
@@ -820,33 +700,19 @@ test_expect_success 'remote big push force' '
 	(
 	cd gitrepo &&
 
-	if test "$CAPABILITY_PUSH" = "t"
+	check_push 0 --force --all <<-\EOF
-	then
+	master
-		check_push 0 --force --all <<-\EOF
+	good_bmark
-		master:forced-update
+	branches/good_branch
-		good_bmark:forced-update
+	new_bmark:new
-		branches/good_branch:forced-update
+	branches/new_branch:new
-		new_bmark:new
+	bad_bmark1:forced-update
-		branches/new_branch:new
+	bad_bmark2:forced-update
-		bad_bmark1:forced-update
+	branches/bad_branch:forced-update
-		bad_bmark2:forced-update
+	EOF
-		branches/bad_branch:forced-update
-		EOF
-	else
-		check_push 0 --force --all <<-\EOF
-		master
-		good_bmark
-		branches/good_branch
-		new_bmark:new
-		branches/new_branch:new
-		bad_bmark1:forced-update
-		bad_bmark2:forced-update
-		branches/bad_branch:forced-update
-		EOF
-	fi
 	) &&
 
-	check gitrepo origin/master two &&
+	check_branch hgrepo default six &&
 	check_branch hgrepo good_branch eight &&
 	check_branch hgrepo bad_branch nine &&
 	check_branch hgrepo new_branch ten &&
@@ -856,7 +722,7 @@ test_expect_success 'remote big push force' '
 	check_bookmark hgrepo new_bmark six
 '
 
-test_expect_success 'remote big push dry-run' '
+test_expect_failure 'remote big push dry-run' '
 	test_when_finished "rm -rf hgrepo gitrepo*" &&
 
 	setup_big_push
@@ -864,27 +730,16 @@ test_expect_success 'remote big push dry-run' '
 	(
 	cd gitrepo &&
 
-	if test "$CAPABILITY_PUSH" = "t"
+	check_push 1 --dry-run --all <<-\EOF &&
-	then
+	master
-		# cap push handles refs one by one
+	good_bmark
-		# so it will still correctly report several ok
+	branches/good_branch
-		check_push 1 --dry-run --all <<-\EOF
+	new_bmark:new
-		master
+	branches/new_branch:new
-		good_bmark
+	bad_bmark1:non-fast-forward
-		branches/good_branch
+	bad_bmark2:non-fast-forward
-		new_bmark:new
+	branches/bad_branch:non-fast-forward
-		branches/new_branch:new
+	EOF
-		bad_bmark1:non-fast-forward
-		bad_bmark2:non-fast-forward
-		branches/bad_branch:non-fast-forward
-		EOF
-	else
-		check_push 1 --dry-run --all <<-\EOF
-		bad_bmark1:non-fast-forward
-		bad_bmark2:non-fast-forward
-		branches/bad_branch:non-fast-forward
-		EOF
-	fi &&
 
 	check_push 0 --dry-run master good_bmark new_bmark branches/good_branch branches/new_branch <<-\EOF
 	master
@@ -895,60 +750,14 @@ test_expect_success 'remote big push dry-run' '
 	EOF
 	) &&
 
-	check gitrepo origin/master one &&
 	check_branch hgrepo default one &&
 	check_branch hgrepo good_branch "good branch" &&
 	check_branch hgrepo bad_branch "bad branch" &&
-	check_branch hgrepo new_branch &&
+	check_branch hgrepo new_branch '' &&
 	check_bookmark hgrepo good_bmark one &&
 	check_bookmark hgrepo bad_bmark1 one &&
 	check_bookmark hgrepo bad_bmark2 one &&
-	check_bookmark hgrepo new_bmark
+	check_bookmark hgrepo new_bmark ''
-'
-
-test_expect_success 'remote big push force dry-run' '
-	test_when_finished "rm -rf hgrepo gitrepo*" &&
-
-	setup_big_push
-
-	(
-	cd gitrepo &&
-
-	if test "$CAPABILITY_PUSH" = "t"
-	then
-		check_push 0 --force --dry-run --all <<-\EOF
-		master:forced-update
-		good_bmark:forced-update
-		branches/good_branch:forced-update
-		new_bmark:new
-		branches/new_branch:new
-		bad_bmark1:forced-update
-		bad_bmark2:forced-update
-		branches/bad_branch:forced-update
-		EOF
-	else
-		check_push 0 --force --dry-run --all <<-\EOF
-		master
-		good_bmark
-		branches/good_branch
-		new_bmark:new
-		branches/new_branch:new
-		bad_bmark1:forced-update
-		bad_bmark2:forced-update
-		branches/bad_branch:forced-update
-		EOF
-	fi
-	) &&
-
-	check gitrepo origin/master one &&
-	check_branch hgrepo default one &&
-	check_branch hgrepo good_branch "good branch" &&
-	check_branch hgrepo bad_branch "bad branch" &&
-	check_branch hgrepo new_branch &&
-	check_bookmark hgrepo good_bmark one &&
-	check_bookmark hgrepo bad_bmark1 one &&
-	check_bookmark hgrepo bad_bmark2 one &&
-	check_bookmark hgrepo new_bmark
 '
 
 test_expect_success 'remote double failed push' '
@@ -974,78 +783,6 @@ test_expect_success 'remote double failed push' '
 	test_expect_code 1 git push
 	)
 '
-test_expect_success 'fetch prune' '
-	test_when_finished "rm -rf gitrepo hgrepo" &&
-
-	(
-	hg init hgrepo &&
-	cd hgrepo &&
-	echo zero > content &&
-	hg add content &&
-	hg commit -m zero &&
-	echo feature-a > content &&
-	hg commit -m feature-a
-	hg bookmark feature-a
-	) &&
-
-	git clone "hg::hgrepo" gitrepo &&
-	check gitrepo origin/feature-a feature-a &&
-
-	(
-	cd hgrepo &&
-	hg bookmark -d feature-a
-	) &&
-
-	(
-	cd gitrepo &&
-	git fetch --prune origin
-	git branch -a > out &&
-	! grep feature-a out
-	)
-'
-
-test_expect_success 'fetch multiple independent histories' '
-	test_when_finished "rm -rf gitrepo hgrepo" &&
-
-	(
-	hg init hgrepo &&
-	cd hgrepo &&
-	echo zero > content &&
-	hg add content &&
-	hg commit -m zero &&
-	hg up -r null &&
-	echo another > ocontent &&
-	hg add ocontent &&
-	hg commit -m one
-	) &&
-
-	# -r 1 acts as master
-	(
-	git init --bare gitrepo && cd gitrepo &&
-	git remote add origin hg::../hgrepo &&
-	git fetch origin refs/heads/*:refs/heads/*
-	) &&
-
-	(
-	cd hgrepo &&
-	hg up 0 &&
-	echo two > content &&
-	hg commit -m two
-	) &&
-
-	# now master already exists
-	# -r 2 becomes master head which has rev 0 as ancestor
-	# so when importing (parentless) rev 0, a reset is needed
-	# (to ensure rev 0 is not given a parent commit)
-	(
-	cd gitrepo &&
-	git fetch origin &&
-	git log --format="%s" origin/master > ../actual
-	) &&
-
-	hg -R hgrepo log -r . -f --template "{desc}\n" > expected &&
-	test_cmp actual expected
-'
 
 test_expect_success 'clone remote with null bookmark, then push' '
 	test_when_finished "rm -rf gitrepo* hgrepo*" &&
@@ -1091,8 +828,7 @@ test_expect_success 'notes' '
 	test_cmp expected actual
 '
 
-testpushupdatesnotesdesc='push updates notes'
+test_expect_failure 'push updates notes' '
-testpushupdatesnotes='
 	test_when_finished "rm -rf hgrepo gitrepo" &&
 
 	(
@@ -1108,7 +844,7 @@ testpushupdatesnotes='
 	(
 	cd gitrepo &&
 	echo two > content &&
-	git commit -a -m two &&
+	git commit -a -m two
 	git push
 	) &&
 
@@ -1117,38 +853,6 @@ testpushupdatesnotes='
 	test_cmp expected actual
 '
 
-if test "$CAPABILITY_PUSH" = "t"
-then
-test_expect_success "$testpushupdatesnotesdesc" "$testpushupdatesnotes"
-else
-test_expect_failure "$testpushupdatesnotesdesc" "$testpushupdatesnotes"
-fi
-
-test_expect_success 'push bookmark without changesets' '
-	test_when_finished "rm -rf hgrepo gitrepo" &&
-
-	(
-	hg init hgrepo &&
-	cd hgrepo &&
-	echo one > content &&
-	hg add content &&
-	hg commit -m one
-	) &&
-
-	git clone "hg::hgrepo" gitrepo &&
-
-	(
-	cd gitrepo &&
-	echo two > content &&
-	git commit -a -m two &&
-	git push origin master &&
-	git branch feature-a &&
-	git push origin feature-a
-	) &&
-
-	check_bookmark hgrepo feature-a two
-'
-
 test_expect_success 'pull tags' '
 	test_when_finished "rm -rf hgrepo gitrepo" &&
 
@@ -1194,7 +898,7 @@ test_expect_success 'push merged named branch' '
 	git push
 	) &&
 
-	cat > expected <<-EOF &&
+	cat > expected <<-EOF
 	Merge
 	three
 	two
@@ -1235,7 +939,7 @@ test_expect_success 'push tag different branch' '
 	cd hgrepo &&
 	echo one > content &&
 	hg add content &&
-	hg commit -m one &&
+	hg commit -m one
 	hg branch feature &&
 	echo two > content &&
 	hg commit -m two
@@ -1320,78 +1024,4 @@ test_expect_success 'clone replace directory with a file' '
 	check_files gitrepo "dir_or_file"
 '
 
-test_expect_success 'clone can ignore invalid refnames' '
-	test_when_finished "rm -rf hgrepo gitrepo" &&
-
-	(
-	hg init hgrepo &&
-	cd hgrepo &&
-
-	touch test.txt &&
-	hg add test.txt &&
-	hg commit -m master &&
-	hg branch parent &&
-	echo test >test.txt &&
-	hg commit -m test &&
-	hg branch parent/child &&
-	echo test1 >test.txt &&
-	hg commit -m test1
-	) &&
-
-	git clone -c remote-hg.ignore-name=child "hg::hgrepo" gitrepo &&
-	check_files gitrepo "test.txt"
-'
-
-test_expect_success 'push annotated tag' '
-	test_when_finished "rm -rf hgrepo gitrepo" &&
-
-	(
-	hg init hgrepo &&
-	cd hgrepo &&
-	echo one > content &&
-	hg add content &&
-	hg commit -m one
-	) &&
-
-	(
-	git clone "hg::hgrepo" gitrepo &&
-	cd gitrepo &&
-	git tag -m "Version 1.0" v1.0 &&
-	git push --tags
-	) &&
-
-	cat > expected <<-\EOF &&
-	tip:Version 1.0:C O Mitter <committer@example.com>
-	v1.0:one:H G Wells <wells@example.com>
-	EOF
-
-	hg -R hgrepo log --template "{tags}:{desc}:{author}\n" > actual &&
-
-	test_cmp expected actual
-'
-
-test_expect_success 'timezone issues with negative offsets' '
-	test_when_finished "rm -rf hgrepo gitrepo1 gitrepo2" &&
-
-	hg init hgrepo &&
-
-	(
-	git clone "hg::hgrepo" gitrepo1 &&
-	cd gitrepo1 &&
-	echo two >> content &&
-	git add content &&
-	git commit -m two --date="2016-09-26 00:00:00 -0230" &&
-	git push
-	) &&
-
-	git clone "hg::hgrepo" gitrepo2 &&
-
-	git --git-dir=gitrepo1/.git log -1 --format="%ai" > expected &&
-	git --git-dir=gitrepo2/.git log -1 --format="%ai" > actual &&
-	test_cmp expected actual
-'
-
-if test "$CAPABILITY_PUSH" != "t"
-then
 test_done
-fi

test/sharness.sh

@@ -0,0 +1,711 @@
+#!/bin/sh
+#
+# Copyright (c) 2011-2012 Mathias Lafeldt
+# Copyright (c) 2005-2012 Git project
+# Copyright (c) 2005-2012 Junio C Hamano
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see http://www.gnu.org/licenses/ .
+
+# Public: Current version of Sharness.
+SHARNESS_VERSION="0.3.0"
+export SHARNESS_VERSION
+
+# Public: The file extension for tests.  By default, it is set to "t".
+: ${SHARNESS_TEST_EXTENSION:=t}
+export SHARNESS_TEST_EXTENSION
+
+# Keep the original TERM for say_color
+ORIGINAL_TERM=$TERM
+
+# For repeatability, reset the environment to a known state.
+LANG=C
+LC_ALL=C
+PAGER=cat
+TZ=UTC
+TERM=dumb
+EDITOR=:
+export LANG LC_ALL PAGER TZ TERM EDITOR
+unset VISUAL CDPATH GREP_OPTIONS
+
+# Line feed
+LF='
+'
+
+[ "x$ORIGINAL_TERM" != "xdumb" ] && (
+		TERM=$ORIGINAL_TERM &&
+		export TERM &&
+		[ -t 1 ] &&
+		tput bold >/dev/null 2>&1 &&
+		tput setaf 1 >/dev/null 2>&1 &&
+		tput sgr0 >/dev/null 2>&1
+	) &&
+	color=t
+
+while test "$#" -ne 0; do
+	case "$1" in
+	-d|--d|--de|--deb|--debu|--debug)
+		debug=t; shift ;;
+	-i|--i|--im|--imm|--imme|--immed|--immedi|--immedia|--immediat|--immediate)
+		immediate=t; shift ;;
+	-l|--l|--lo|--lon|--long|--long-|--long-t|--long-te|--long-tes|--long-test|--long-tests)
+		TEST_LONG=t; export TEST_LONG; shift ;;
+	-h|--h|--he|--hel|--help)
+		help=t; shift ;;
+	-v|--v|--ve|--ver|--verb|--verbo|--verbos|--verbose)
+		verbose=t; shift ;;
+	-q|--q|--qu|--qui|--quie|--quiet)
+		# Ignore --quiet under a TAP::Harness. Saying how many tests
+		# passed without the ok/not ok details is always an error.
+		test -z "$HARNESS_ACTIVE" && quiet=t; shift ;;
+	--no-color)
+		color=; shift ;;
+	--root=*)
+		root=$(expr "z$1" : 'z[^=]*=\(.*\)')
+		shift ;;
+	*)
+		echo "error: unknown test option '$1'" >&2; exit 1 ;;
+	esac
+done
+
+if test -n "$color"; then
+	say_color() {
+		(
+		TERM=$ORIGINAL_TERM
+		export TERM
+		case "$1" in
+		error)
+			tput bold; tput setaf 1;; # bold red
+		skip)
+			tput setaf 4;; # blue
+		warn)
+			tput setaf 3;; # brown/yellow
+		pass)
+			tput setaf 2;; # green
+		info)
+			tput setaf 6;; # cyan
+		*)
+			test -n "$quiet" && return;;
+		esac
+		shift
+		printf "%s" "$*"
+		tput sgr0
+		echo
+		)
+	}
+else
+	say_color() {
+		test -z "$1" && test -n "$quiet" && return
+		shift
+		printf "%s\n" "$*"
+	}
+fi
+
+error() {
+	say_color error "error: $*"
+	EXIT_OK=t
+	exit 1
+}
+
+say() {
+	say_color info "$*"
+}
+
+test -n "$test_description" || error "Test script did not set test_description."
+
+if test "$help" = "t"; then
+	echo "$test_description"
+	exit 0
+fi
+
+exec 5>&1
+exec 6<&0
+if test "$verbose" = "t"; then
+	exec 4>&2 3>&1
+else
+	exec 4>/dev/null 3>/dev/null
+fi
+
+test_failure=0
+test_count=0
+test_fixed=0
+test_broken=0
+test_success=0
+
+die() {
+	code=$?
+	if test -n "$EXIT_OK"; then
+		exit $code
+	else
+		echo >&5 "FATAL: Unexpected exit with code $code"
+		exit 1
+	fi
+}
+
+EXIT_OK=
+trap 'die' EXIT
+
+# Public: Define that a test prerequisite is available.
+#
+# The prerequisite can later be checked explicitly using test_have_prereq or
+# implicitly by specifying the prerequisite name in calls to test_expect_success
+# or test_expect_failure.
+#
+# $1 - Name of prerequiste (a simple word, in all capital letters by convention)
+#
+# Examples
+#
+#   # Set PYTHON prerequisite if interpreter is available.
+#   command -v python >/dev/null && test_set_prereq PYTHON
+#
+#   # Set prerequisite depending on some variable.
+#   test -z "$NO_GETTEXT" && test_set_prereq GETTEXT
+#
+# Returns nothing.
+test_set_prereq() {
+	satisfied_prereq="$satisfied_prereq$1 "
+}
+satisfied_prereq=" "
+
+# Public: Check if one or more test prerequisites are defined.
+#
+# The prerequisites must have previously been set with test_set_prereq.
+# The most common use of this is to skip all the tests if some essential
+# prerequisite is missing.
+#
+# $1 - Comma-separated list of test prerequisites.
+#
+# Examples
+#
+#   # Skip all remaining tests if prerequisite is not set.
+#   if ! test_have_prereq PERL; then
+#       skip_all='skipping perl interface tests, perl not available'
+#       test_done
+#   fi
+#
+# Returns 0 if all prerequisites are defined or 1 otherwise.
+test_have_prereq() {
+	# prerequisites can be concatenated with ','
+	save_IFS=$IFS
+	IFS=,
+	set -- $*
+	IFS=$save_IFS
+
+	total_prereq=0
+	ok_prereq=0
+	missing_prereq=
+
+	for prerequisite; do
+		case "$prerequisite" in
+		!*)
+			negative_prereq=t
+			prerequisite=${prerequisite#!}
+			;;
+		*)
+			negative_prereq=
+		esac
+
+		total_prereq=$(($total_prereq + 1))
+		case "$satisfied_prereq" in
+		*" $prerequisite "*)
+			satisfied_this_prereq=t
+			;;
+		*)
+			satisfied_this_prereq=
+		esac
+
+		case "$satisfied_this_prereq,$negative_prereq" in
+		t,|,t)
+			ok_prereq=$(($ok_prereq + 1))
+			;;
+		*)
+			# Keep a list of missing prerequisites; restore
+			# the negative marker if necessary.
+			prerequisite=${negative_prereq:+!}$prerequisite
+			if test -z "$missing_prereq"; then
+				missing_prereq=$prerequisite
+			else
+				missing_prereq="$prerequisite,$missing_prereq"
+			fi
+		esac
+	done
+
+	test $total_prereq = $ok_prereq
+}
+
+# You are not expected to call test_ok_ and test_failure_ directly, use
+# the text_expect_* functions instead.
+
+test_ok_() {
+	test_success=$(($test_success + 1))
+	say_color "" "ok $test_count - $@"
+}
+
+test_failure_() {
+	test_failure=$(($test_failure + 1))
+	say_color error "not ok $test_count - $1"
+	shift
+	echo "$@" | sed -e 's/^/#	/'
+	test "$immediate" = "" || { EXIT_OK=t; exit 1; }
+}
+
+test_known_broken_ok_() {
+	test_fixed=$(($test_fixed + 1))
+	say_color error "ok $test_count - $@ # TODO known breakage vanished"
+}
+
+test_known_broken_failure_() {
+	test_broken=$(($test_broken + 1))
+	say_color warn "not ok $test_count - $@ # TODO known breakage"
+}
+
+# Public: Execute commands in debug mode.
+#
+# Takes a single argument and evaluates it only when the test script is started
+# with --debug. This is primarily meant for use during the development of test
+# scripts.
+#
+# $1 - Commands to be executed.
+#
+# Examples
+#
+#   test_debug "cat some_log_file"
+#
+# Returns the exit code of the last command executed in debug mode or 0
+#   otherwise.
+test_debug() {
+	test "$debug" = "" || eval "$1"
+}
+
+test_eval_() {
+	# This is a separate function because some tests use
+	# "return" to end a test_expect_success block early.
+	eval </dev/null >&3 2>&4 "$*"
+}
+
+test_run_() {
+	test_cleanup=:
+	expecting_failure=$2
+	test_eval_ "$1"
+	eval_ret=$?
+
+	if test -z "$immediate" || test $eval_ret = 0 || test -n "$expecting_failure"; then
+		test_eval_ "$test_cleanup"
+	fi
+	if test "$verbose" = "t" && test -n "$HARNESS_ACTIVE"; then
+		echo ""
+	fi
+	return "$eval_ret"
+}
+
+test_skip_() {
+	test_count=$(($test_count + 1))
+	to_skip=
+	for skp in $SKIP_TESTS; do
+		case $this_test.$test_count in
+		$skp)
+			to_skip=t
+			break
+		esac
+	done
+	if test -z "$to_skip" && test -n "$test_prereq" && ! test_have_prereq "$test_prereq"; then
+		to_skip=t
+	fi
+	case "$to_skip" in
+	t)
+		of_prereq=
+		if test "$missing_prereq" != "$test_prereq"; then
+			of_prereq=" of $test_prereq"
+		fi
+
+		say_color skip >&3 "skipping test: $@"
+		say_color skip "ok $test_count # skip $1 (missing $missing_prereq${of_prereq})"
+		: true
+		;;
+	*)
+		false
+		;;
+	esac
+}
+
+# Public: Run test commands and expect them to succeed.
+#
+# When the test passed, an "ok" message is printed and the number of successful
+# tests is incremented. When it failed, a "not ok" message is printed and the
+# number of failed tests is incremented.
+#
+# With --immediate, exit test immediately upon the first failed test.
+#
+# Usually takes two arguments:
+# $1 - Test description
+# $2 - Commands to be executed.
+#
+# With three arguments, the first will be taken to be a prerequisite:
+# $1 - Comma-separated list of test prerequisites. The test will be skipped if
+#      not all of the given prerequisites are set. To negate a prerequisite,
+#      put a "!" in front of it.
+# $2 - Test description
+# $3 - Commands to be executed.
+#
+# Examples
+#
+#   test_expect_success \
+#       'git-write-tree should be able to write an empty tree.' \
+#       'tree=$(git-write-tree)'
+#
+#   # Test depending on one prerequisite.
+#   test_expect_success TTY 'git --paginate rev-list uses a pager' \
+#       ' ... '
+#
+#   # Multiple prerequisites are separated by a comma.
+#   test_expect_success PERL,PYTHON 'yo dawg' \
+#       ' test $(perl -E 'print eval "1 +" . qx[python -c "print 2"]') == "4" '
+#
+# Returns nothing.
+test_expect_success() {
+	test "$#" = 3 && { test_prereq=$1; shift; } || test_prereq=
+	test "$#" = 2 || error "bug in the test script: not 2 or 3 parameters to test_expect_success"
+	export test_prereq
+	if ! test_skip_ "$@"; then
+		say >&3 "expecting success: $2"
+		if test_run_ "$2"; then
+			test_ok_ "$1"
+		else
+			test_failure_ "$@"
+		fi
+	fi
+	echo >&3 ""
+}
+
+# Public: Run test commands and expect them to fail. Used to demonstrate a known
+# breakage.
+#
+# This is NOT the opposite of test_expect_success, but rather used to mark a
+# test that demonstrates a known breakage.
+#
+# When the test passed, an "ok" message is printed and the number of fixed tests
+# is incremented. When it failed, a "not ok" message is printed and the number
+# of tests still broken is incremented.
+#
+# Failures from these tests won't cause --immediate to stop.
+#
+# Usually takes two arguments:
+# $1 - Test description
+# $2 - Commands to be executed.
+#
+# With three arguments, the first will be taken to be a prerequisite:
+# $1 - Comma-separated list of test prerequisites. The test will be skipped if
+#      not all of the given prerequisites are set. To negate a prerequisite,
+#      put a "!" in front of it.
+# $2 - Test description
+# $3 - Commands to be executed.
+#
+# Returns nothing.
+test_expect_failure() {
+	test "$#" = 3 && { test_prereq=$1; shift; } || test_prereq=
+	test "$#" = 2 || error "bug in the test script: not 2 or 3 parameters to test_expect_failure"
+	export test_prereq
+	if ! test_skip_ "$@"; then
+		say >&3 "checking known breakage: $2"
+		if test_run_ "$2" expecting_failure; then
+			test_known_broken_ok_ "$1"
+		else
+			test_known_broken_failure_ "$1"
+		fi
+	fi
+	echo >&3 ""
+}
+
+# Public: Run command and ensure that it fails in a controlled way.
+#
+# Use it instead of "! <command>". For example, when <command> dies due to a
+# segfault, test_must_fail diagnoses it as an error, while "! <command>" would
+# mistakenly be treated as just another expected failure.
+#
+# This is one of the prefix functions to be used inside test_expect_success or
+# test_expect_failure.
+#
+# $1.. - Command to be executed.
+#
+# Examples
+#
+#   test_expect_success 'complain and die' '
+#       do something &&
+#       do something else &&
+#       test_must_fail git checkout ../outerspace
+#   '
+#
+# Returns 1 if the command succeeded (exit code 0).
+# Returns 1 if the command died by signal (exit codes 130-192)
+# Returns 1 if the command could not be found (exit code 127).
+# Returns 0 otherwise.
+test_must_fail() {
+	"$@"
+	exit_code=$?
+	if test $exit_code = 0; then
+		echo >&2 "test_must_fail: command succeeded: $*"
+		return 1
+	elif test $exit_code -gt 129 -a $exit_code -le 192; then
+		echo >&2 "test_must_fail: died by signal: $*"
+		return 1
+	elif test $exit_code = 127; then
+		echo >&2 "test_must_fail: command not found: $*"
+		return 1
+	fi
+	return 0
+}
+
+# Public: Run command and ensure that it succeeds or fails in a controlled way.
+#
+# Similar to test_must_fail, but tolerates success too. Use it instead of
+# "<command> || :" to catch failures caused by a segfault, for instance.
+#
+# This is one of the prefix functions to be used inside test_expect_success or
+# test_expect_failure.
+#
+# $1.. - Command to be executed.
+#
+# Examples
+#
+#   test_expect_success 'some command works without configuration' '
+#       test_might_fail git config --unset all.configuration &&
+#       do something
+#   '
+#
+# Returns 1 if the command died by signal (exit codes 130-192)
+# Returns 1 if the command could not be found (exit code 127).
+# Returns 0 otherwise.
+test_might_fail() {
+	"$@"
+	exit_code=$?
+	if test $exit_code -gt 129 -a $exit_code -le 192; then
+		echo >&2 "test_might_fail: died by signal: $*"
+		return 1
+	elif test $exit_code = 127; then
+		echo >&2 "test_might_fail: command not found: $*"
+		return 1
+	fi
+	return 0
+}
+
+# Public: Run command and ensure it exits with a given exit code.
+#
+# This is one of the prefix functions to be used inside test_expect_success or
+# test_expect_failure.
+#
+# $1   - Expected exit code.
+# $2.. - Command to be executed.
+#
+# Examples
+#
+#   test_expect_success 'Merge with d/f conflicts' '
+#       test_expect_code 1 git merge "merge msg" B master
+#   '
+#
+# Returns 0 if the expected exit code is returned or 1 otherwise.
+test_expect_code() {
+	want_code=$1
+	shift
+	"$@"
+	exit_code=$?
+	if test $exit_code = $want_code; then
+		return 0
+	fi
+
+	echo >&2 "test_expect_code: command exited with $exit_code, we wanted $want_code $*"
+	return 1
+}
+
+# Public: Compare two files to see if expected output matches actual output.
+#
+# The TEST_CMP variable defines the command used for the comparision; it
+# defaults to "diff -u". Only when the test script was started with --verbose,
+# will the command's output, the diff, be printed to the standard output.
+#
+# This is one of the prefix functions to be used inside test_expect_success or
+# test_expect_failure.
+#
+# $1 - Path to file with expected output.
+# $2 - Path to file with actual output.
+#
+# Examples
+#
+#   test_expect_success 'foo works' '
+#       echo expected >expected &&
+#       foo >actual &&
+#       test_cmp expected actual
+#   '
+#
+# Returns the exit code of the command set by TEST_CMP.
+test_cmp() {
+	${TEST_CMP:-diff -u} "$@"
+}
+
+# Public: Schedule cleanup commands to be run unconditionally at the end of a
+# test.
+#
+# If some cleanup command fails, the test will not pass. With --immediate, no
+# cleanup is done to help diagnose what went wrong.
+#
+# This is one of the prefix functions to be used inside test_expect_success or
+# test_expect_failure.
+#
+# $1.. - Commands to prepend to the list of cleanup commands.
+#
+# Examples
+#
+#   test_expect_success 'test core.capslock' '
+#       git config core.capslock true &&
+#       test_when_finished "git config --unset core.capslock" &&
+#       do_something
+#   '
+#
+# Returns the exit code of the last cleanup command executed.
+test_when_finished() {
+	test_cleanup="{ $*
+		} && (exit \"\$eval_ret\"); eval_ret=\$?; $test_cleanup"
+}
+
+# Public: Summarize test results and exit with an appropriate error code.
+#
+# Must be called at the end of each test script.
+#
+# Can also be used to stop tests early and skip all remaining tests. For this,
+# set skip_all to a string explaining why the tests were skipped before calling
+# test_done.
+#
+# Examples
+#
+#   # Each test script must call test_done at the end.
+#   test_done
+#
+#   # Skip all remaining tests if prerequisite is not set.
+#   if ! test_have_prereq PERL; then
+#       skip_all='skipping perl interface tests, perl not available'
+#       test_done
+#   fi
+#
+# Returns 0 if all tests passed or 1 if there was a failure.
+test_done() {
+	EXIT_OK=t
+
+	if test -z "$HARNESS_ACTIVE"; then
+		test_results_dir="$SHARNESS_TEST_DIRECTORY/test-results"
+		mkdir -p "$test_results_dir"
+		test_results_path="$test_results_dir/${SHARNESS_TEST_FILE%.$SHARNESS_TEST_EXTENSION}.$$.counts"
+
+		cat >>"$test_results_path" <<-EOF
+		total $test_count
+		success $test_success
+		fixed $test_fixed
+		broken $test_broken
+		failed $test_failure
+
+		EOF
+	fi
+
+	if test "$test_fixed" != 0; then
+		say_color error "# $test_fixed known breakage(s) vanished; please update test(s)"
+	fi
+	if test "$test_broken" != 0; then
+		say_color warn "# still have $test_broken known breakage(s)"
+	fi
+	if test "$test_broken" != 0 || test "$test_fixed" != 0; then
+		test_remaining=$(( $test_count - $test_broken - $test_fixed ))
+		msg="remaining $test_remaining test(s)"
+	else
+		test_remaining=$test_count
+		msg="$test_count test(s)"
+	fi
+
+	case "$test_failure" in
+	0)
+		# Maybe print SKIP message
+		if test -n "$skip_all" && test $test_count -gt 0; then
+			error "Can't use skip_all after running some tests"
+		fi
+		[ -z "$skip_all" ] || skip_all=" # SKIP $skip_all"
+
+		if test $test_remaining -gt 0; then
+			say_color pass "# passed all $msg"
+		fi
+		say "1..$test_count$skip_all"
+
+		test -d "$remove_trash" &&
+		cd "$(dirname "$remove_trash")" &&
+		rm -rf "$(basename "$remove_trash")"
+
+		exit 0 ;;
+
+	*)
+		say_color error "# failed $test_failure among $msg"
+		say "1..$test_count"
+
+		exit 1 ;;
+
+	esac
+}
+
+# Public: Root directory containing tests. Tests can override this variable,
+# e.g. for testing Sharness itself.
+: ${SHARNESS_TEST_DIRECTORY:=$(pwd)}
+export SHARNESS_TEST_DIRECTORY
+
+# Public: Build directory that will be added to PATH. By default, it is set to
+# the parent directory of SHARNESS_TEST_DIRECTORY.
+: ${SHARNESS_BUILD_DIRECTORY:="$SHARNESS_TEST_DIRECTORY/.."}
+PATH="$SHARNESS_BUILD_DIRECTORY:$PATH"
+export PATH SHARNESS_BUILD_DIRECTORY
+
+# Public: Path to test script currently executed.
+SHARNESS_TEST_FILE="$0"
+export SHARNESS_TEST_FILE
+
+# Prepare test area.
+test_dir="trash directory.$(basename "$SHARNESS_TEST_FILE" ".$SHARNESS_TEST_EXTENSION")"
+test -n "$root" && test_dir="$root/$test_dir"
+case "$test_dir" in
+/*) SHARNESS_TRASH_DIRECTORY="$test_dir" ;;
+ *) SHARNESS_TRASH_DIRECTORY="$SHARNESS_TEST_DIRECTORY/$test_dir" ;;
+esac
+test "$debug" = "t" || remove_trash="$SHARNESS_TRASH_DIRECTORY"
+rm -rf "$test_dir" || {
+	EXIT_OK=t
+	echo >&5 "FATAL: Cannot prepare test area"
+	exit 1
+}
+
+# Public: Empty trash directory, the test area, provided for each test. The HOME
+# variable is set to that directory too.
+export SHARNESS_TRASH_DIRECTORY
+
+HOME="$SHARNESS_TRASH_DIRECTORY"
+export HOME
+
+mkdir -p "$test_dir" || exit 1
+# Use -P to resolve symlinks in our working directory so that the cwd
+# in subprocesses like git equals our $PWD (for pathname comparisons).
+cd -P "$test_dir" || exit 1
+
+this_test=${SHARNESS_TEST_FILE##*/}
+this_test=${this_test%.$SHARNESS_TEST_EXTENSION}
+for skp in $SKIP_TESTS; do
+	case "$this_test" in
+	$skp)
+		say_color info >&3 "skipping test $this_test altogether"
+		skip_all="skip all tests in $this_test"
+		test_done
+	esac
+done
+
+# vi: set ts=4 sw=4 noet :

test/test-lib.sh

@@ -0,0 +1,12 @@
+#!/bin/sh
+
+. ./sharness.sh
+
+test_set_prereq PYTHON
+
+GIT_AUTHOR_EMAIL=author@example.com
+GIT_AUTHOR_NAME='A U Thor'
+GIT_COMMITTER_EMAIL=committer@example.com
+GIT_COMMITTER_NAME='C O Mitter'
+export GIT_AUTHOR_EMAIL GIT_AUTHOR_NAME
+export GIT_COMMITTER_EMAIL GIT_COMMITTER_NAME

tools/.gitignore

@@ -1 +0,0 @@
-results.txt

tools/check-versions

@@ -1,198 +0,0 @@
-#!/usr/bin/env ruby
-
-#
-# Copyright (c) 2019-2023 Felipe Contreras
-#
-# This script runs the tests for all versions of hg.
-#
-# You can run it without arguments, in which case it runs the tests for all
-# versions in `versions.txt`.
-#
-# Or you can specify a single version manually:
-#
-#   ./check-versions 6.3
-#
-
-require 'fileutils'
-require 'tmpdir'
-
-$tests = %w[main.t bidi.t hg-git.t]
-$workdir = "#{Dir.home}/.cache/git-remote-hg"
-$builddir = Dir.mktmpdir("git-remote-hg-build-")
-$testoutdir = Dir.mktmpdir("git-remote-hg-tests-")
-
-at_exit {
-  FileUtils.remove_entry($builddir)
-  FileUtils.remove_entry($testoutdir)
-}
-
-QUIET, LOW, HIGH = (1..3).to_a
-$verbosity = LOW
-
-# Util {{{1
-
-def section(text)
-  puts [nil, text, '=' * text.size]
-end
-
-def title(text)
-  puts [nil, text, '-' * text.size] unless $verbosity < HIGH
-end
-
-def run_cmd(cmd, fatal: true)
-  puts cmd.join(' ') unless $verbosity < HIGH
-  result = system(*cmd)
-  unless result or not fatal
-    STDERR.puts "Failed to run command '%s'" % cmd.join(' ')
-    exit -1
-  end
-  result
-end
-
-def check_version(a, b)
-  return true if a == '@'
-  a = a.split('.').map(&:to_i)
-  b = b.split('.').map(&:to_i)
-  (a <=> b) >= 0
-end
-
-# Hg {{{1
-
-class Hg
-
-  def initialize
-    @url = 'https://www.mercurial-scm.org/repo/hg'
-  end
-
-  def dir
-    "#{$workdir}/hg"
-  end
-
-  def clone
-    run_cmd %w[hg clone -q] + [@url, dir]
-  end
-
-  def checkout(version)
-    Dir.chdir(dir) do
-      run_cmd %w[hg update --clean -q] << version
-      checkout_fix(version)
-    end
-  end
-
-  def build
-    Dir.chdir(dir) do
-      targets = %w[build_py build_ext].map { |e| [e, '--build-lib', "#{$builddir}/python"] }
-      run_cmd %w[python setup.py --quiet] + targets.flatten
-    end
-  end
-
-  def checkout_fix(version)
-    FileUtils.cp('hg', "#{$builddir}/bin/")
-
-    return if check_version(version, '4.3')
-
-    if run_cmd %W[hg import -q --no-commit #{__dir__}/hg_setup_hack_2.4.patch], fatal: false
-      File.write('.hg_force_version', "%s\n" % version)
-    else
-      File.write('mercurial/__version__.py', "version = \"%s\"\n" % version)
-    end
-  end
-
-end
-
-# Functions {{{1
-
-def setup
-  dirs = %w[bin python]
-  FileUtils.mkdir_p(dirs.map { |e| "#{$builddir}/#{e}" })
-  FileUtils.mkdir_p($workdir)
-
-  return if File.exist?($hg.dir)
-
-  if $verbosity < HIGH
-    puts "Cloning hg"
-  else
-    title "Cloning hg"
-  end
-  $hg.clone
-end
-
-def test_env(paths: nil)
-  old = ENV.to_h
-  paths.each do |id, path|
-    name = id.to_s
-    ENV[name] = "#{path}:#{ENV[name]}"
-  end
-  r = yield
-  ENV.replace(old)
-  return r
-end
-
-def run_tests(tests)
-  title "Running tests"
-
-  Dir.chdir("#{__dir__}/../test") do
-    case $verbosity
-    when QUIET
-      tests_opt = tests.join(' ')
-      cmd = "prove -q #{tests_opt} :: -i"
-    when LOW
-      tests_opt = "T='%s'" % tests.join(' ')
-      cmd = "make -j1 #{tests_opt}"
-    else
-      tests_opt = "T='%s'" % tests.join(' ')
-      cmd = "TEST_OPTS='-v -i' make -j1 #{tests_opt}"
-    end
-    system(cmd)
-  end
-end
-
-def check(version)
-  section version
-
-  title "Checking out hg #{version}"
-  $hg.checkout(version)
-
-  title "Building hg"
-  $hg.build
-
-  paths = {
-    PATH: "#{$builddir}/bin",
-    PYTHONPATH: "#{$builddir}/python",
-  }
-
-  test_env(paths: paths) do
-    ENV['SHARNESS_TEST_OUTPUT_DIRECTORY'] = $testoutdir
-    run_tests($tests)
-  end
-end
-
-$hg = Hg.new()
-
-# Main {{{1
-
-setup
-
-$checks = []
-
-$version = ARGV.first
-$checks = File.readlines(__dir__ + '/versions.txt', chomp: true)
-$results = File.open(__dir__ + '/results.txt', 'w')
-
-if $version
-  $verbosity = HIGH
-
-  exit check($version) ? 0 : 1
-else
-  $verbosity = QUIET
-
-  failures = 0
-
-  $checks.each do |version|
-    result = check(version)
-    failures += 1 unless result
-    $results.puts '%s # %s' % [version, result ? 'OK' : 'FAIL']
-  end
-
-  exit 1 unless failures == 0
-end

tools/hg_setup_hack_2.4.patch

@@ -1,15 +0,0 @@
-diff --git a/setup.py b/setup.py
---- a/setup.py
-+++ b/setup.py
-@@ -181,7 +181,10 @@
-     # error 0xc0150004. See: http://bugs.python.org/issue3440
-     env['SystemRoot'] = os.environ['SystemRoot']
- 
--if os.path.isdir('.hg'):
-+if os.path.exists('.hg_force_version'):
-+    with open('.hg_force_version') as f:
-+        version = f.read().rstrip('\n')
-+elif os.path.isdir('.hg'):
-     cmd = [sys.executable, 'hg', 'log', '-r', '.', '--template', '{tags}\n']
-     numerictags = [t for t in runhg(cmd, env).split() if t[0].isdigit()]
-     hgid = runhg([sys.executable, 'hg', 'id', '-i'], env).strip()

tools/versions.txt

@@ -1,47 +0,0 @@
-2.4
-2.5
-2.6
-2.7
-2.8
-2.9
-3.0
-3.1
-3.2
-3.3
-3.4
-3.5
-3.6
-3.7
-3.8
-3.9
-4.0
-4.1
-4.2
-4.3
-4.4
-4.5
-4.6
-4.7
-4.8
-4.9
-5.0
-5.1
-5.2
-5.3
-5.4
-5.5
-5.6
-5.7
-5.8
-5.9
-6.0
-6.1
-6.2
-6.3
-6.4
-6.5
-6.6
-6.7
-6.8
-6.9
-7.0