convert/mtn: convert suspended branches as closed branches

Monotone treats branch closing ("suspending") in a similar manner to how we do
in mercurial - a cert is added to a revision that marks the branch to be hidden.
If a subsequent commit is made, the branch is effectively reopened.

hgext/convert/monotone.py

@@ -1,354 +1,358
 # monotone.py - monotone support for the convert extension
 #
 #  Copyright 2008, 2009 Mikkel Fahnoe Jorgensen <[e-mail]> and
 #  others
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 import os, re
 from mercurial import util
 from common import NoRepo, commit, converter_source, checktool
 from common import commandline
 from mercurial.i18n import _
 
 class monotone_source(converter_source, commandline):
     def __init__(self, ui, path=None, rev=None):
         converter_source.__init__(self, ui, path, rev)
         commandline.__init__(self, ui, 'mtn')
 
         self.ui = ui
         self.path = path
         self.automatestdio = False
         self.rev = rev
 
         norepo = NoRepo(_("%s does not look like a monotone repository")
                         % path)
         if not os.path.exists(os.path.join(path, '_MTN')):
             # Could be a monotone repository (SQLite db file)
             try:
                 header = file(path, 'rb').read(16)
             except:
                 header = ''
             if header != 'SQLite format 3\x00':
                 raise norepo
 
         # regular expressions for parsing monotone output
         space    = r'\s*'
         name     = r'\s+"((?:\\"|[^"])*)"\s*'
         value    = name
         revision = r'\s+\[(\w+)\]\s*'
         lines    = r'(?:.|\n)+'
 
         self.dir_re      = re.compile(space + "dir" + name)
         self.file_re     = re.compile(space + "file" + name +
                                       "content" + revision)
         self.add_file_re = re.compile(space + "add_file" + name +
                                       "content" + revision)
         self.patch_re    = re.compile(space + "patch" + name +
                                       "from" + revision + "to" + revision)
         self.rename_re   = re.compile(space + "rename" + name + "to" + name)
         self.delete_re   = re.compile(space + "delete" + name)
         self.tag_re      = re.compile(space + "tag" + name + "revision" +
                                       revision)
         self.cert_re     = re.compile(lines + space + "name" + name +
                                       "value" + value)
 
         attr = space + "file" + lines + space + "attr" + space
         self.attr_execute_re = re.compile(attr  + '"mtn:execute"' +
                                           space + '"true"')
 
         # cached data
         self.manifest_rev = None
         self.manifest = None
         self.files = None
         self.dirs  = None
 
         checktool('mtn', abort=False)
 
     def mtnrun(self, *args, **kwargs):
         if self.automatestdio:
             return self.mtnrunstdio(*args, **kwargs)
         else:
             return self.mtnrunsingle(*args, **kwargs)
 
     def mtnrunsingle(self, *args, **kwargs):
         kwargs['d'] = self.path
         return self.run0('automate', *args, **kwargs)
 
     def mtnrunstdio(self, *args, **kwargs):
         # Prepare the command in automate stdio format
         command = []
         for k, v in kwargs.iteritems():
             command.append("%s:%s" % (len(k), k))
             if v:
                 command.append("%s:%s" % (len(v), v))
         if command:
             command.insert(0, 'o')
             command.append('e')
 
         command.append('l')
         for arg in args:
             command += "%s:%s" % (len(arg), arg)
         command.append('e')
         command = ''.join(command)
 
         self.ui.debug("mtn: sending '%s'\n" % command)
         self.mtnwritefp.write(command)
         self.mtnwritefp.flush()
 
         return self.mtnstdioreadcommandoutput(command)
 
     def mtnstdioreadpacket(self):
         read = None
         commandnbr = ''
         while read != ':':
             read = self.mtnreadfp.read(1)
             if not read:
                 raise util.Abort(_('bad mtn packet - no end of commandnbr'))
             commandnbr += read
         commandnbr = commandnbr[:-1]
 
         stream = self.mtnreadfp.read(1)
         if stream not in 'mewptl':
             raise util.Abort(_('bad mtn packet - bad stream type %s' % stream))
 
         read = self.mtnreadfp.read(1)
         if read != ':':
             raise util.Abort(_('bad mtn packet - no divider before size'))
 
         read = None
         lengthstr = ''
         while read != ':':
             read = self.mtnreadfp.read(1)
             if not read:
                 raise util.Abort(_('bad mtn packet - no end of packet size'))
             lengthstr += read
         try:
             length = long(lengthstr[:-1])
         except TypeError:
             raise util.Abort(_('bad mtn packet - bad packet size %s')
                 % lengthstr)
 
         read = self.mtnreadfp.read(length)
         if len(read) != length:
             raise util.Abort(_("bad mtn packet - unable to read full packet "
                 "read %s of %s") % (len(read), length))
 
         return (commandnbr, stream, length, read)
 
     def mtnstdioreadcommandoutput(self, command):
         retval = ''
         while True:
             commandnbr, stream, length, output = self.mtnstdioreadpacket()
             self.ui.debug('mtn: read packet %s:%s:%s\n' %
                 (commandnbr, stream, length))
 
             if stream == 'l':
                 # End of command
                 if output != '0':
                     raise util.Abort(_("mtn command '%s' returned %s") %
                         (command, output))
                 break
             elif stream in 'ew':
                 # Error, warning output
                 self.ui.warn(_('%s error:\n') % self.command)
                 self.ui.warn(output)
             elif stream == 'p':
                 # Progress messages
                 self.ui.debug('mtn: ' + output)
             elif stream == 'm':
                 # Main stream - command output
                 retval = output
 
         return retval
 
     def mtnloadmanifest(self, rev):
         if self.manifest_rev == rev:
             return
         self.manifest = self.mtnrun("get_manifest_of", rev).split("\n\n")
         self.manifest_rev = rev
         self.files = {}
         self.dirs = {}
 
         for e in self.manifest:
             m = self.file_re.match(e)
             if m:
                 attr = ""
                 name = m.group(1)
                 node = m.group(2)
                 if self.attr_execute_re.match(e):
                     attr += "x"
                 self.files[name] = (node, attr)
             m = self.dir_re.match(e)
             if m:
                 self.dirs[m.group(1)] = True
 
     def mtnisfile(self, name, rev):
         # a non-file could be a directory or a deleted or renamed file
         self.mtnloadmanifest(rev)
         return name in self.files
 
     def mtnisdir(self, name, rev):
         self.mtnloadmanifest(rev)
         return name in self.dirs
 
     def mtngetcerts(self, rev):
         certs = {"author":"<missing>", "date":"<missing>",
             "changelog":"<missing>", "branch":"<missing>"}
         certlist = self.mtnrun("certs", rev)
         # mtn < 0.45:
         #   key "[e-mail]"
         # mtn >= 0.45:
         #   key [ff58a7ffb771907c4ff68995eada1c4da068d328]
         certlist = re.split('\n\n      key ["\[]', certlist)
         for e in certlist:
             m = self.cert_re.match(e)
             if m:
                 name, value = m.groups()
                 value = value.replace(r'\"', '"')
                 value = value.replace(r'\\', '\\')
                 certs[name] = value
         # Monotone may have subsecond dates: 2005-02-05T09:39:12.364306
         # and all times are stored in UTC
         certs["date"] = certs["date"].split('.')[0] + " UTC"
         return certs
 
     # implement the converter_source interface:
 
     def getheads(self):
         if not self.rev:
             return self.mtnrun("leaves").splitlines()
         else:
             return [self.rev]
 
     def getchanges(self, rev):
         #revision = self.mtncmd("get_revision %s" % rev).split("\n\n")
         revision = self.mtnrun("get_revision", rev).split("\n\n")
         files = {}
         ignoremove = {}
         renameddirs = []
         copies = {}
         for e in revision:
             m = self.add_file_re.match(e)
             if m:
                 files[m.group(1)] = rev
                 ignoremove[m.group(1)] = rev
             m = self.patch_re.match(e)
             if m:
                 files[m.group(1)] = rev
             # Delete/rename is handled later when the convert engine
             # discovers an IOError exception from getfile,
             # but only if we add the "from" file to the list of changes.
             m = self.delete_re.match(e)
             if m:
                 files[m.group(1)] = rev
             m = self.rename_re.match(e)
             if m:
                 toname = m.group(2)
                 fromname = m.group(1)
                 if self.mtnisfile(toname, rev):
                     ignoremove[toname] = 1
                     copies[toname] = fromname
                     files[toname] = rev
                     files[fromname] = rev
                 elif self.mtnisdir(toname, rev):
                     renameddirs.append((fromname, toname))
 
         # Directory renames can be handled only once we have recorded
         # all new files
         for fromdir, todir in renameddirs:
             renamed = {}
             for tofile in self.files:
                 if tofile in ignoremove:
                     continue
                 if tofile.startswith(todir + '/'):
                     renamed[tofile] = fromdir + tofile[len(todir):]
                     # Avoid chained moves like:
                     # d1(/a) => d3/d1(/a)
                     # d2 => d3
                     ignoremove[tofile] = 1
             for tofile, fromfile in renamed.items():
                 self.ui.debug (_("copying file in renamed directory "
                                  "from '%s' to '%s'")
                                % (fromfile, tofile), '\n')
                 files[tofile] = rev
                 copies[tofile] = fromfile
             for fromfile in renamed.values():
                 files[fromfile] = rev
 
         return (files.items(), copies)
 
     def getfile(self, name, rev):
         if not self.mtnisfile(name, rev):
             raise IOError() # file was deleted or renamed
         try:
             data = self.mtnrun("get_file_of", name, r=rev)
         except:
             raise IOError() # file was deleted or renamed
         self.mtnloadmanifest(rev)
         node, attr = self.files.get(name, (None, ""))
         return data, attr
 
     def getcommit(self, rev):
-        certs   = self.mtngetcerts(rev)
+        extra = {}
+        certs = self.mtngetcerts(rev)
+        if certs.get('suspend') == certs["branch"]:
+            extra['close'] = '1'
         return commit(
             author=certs["author"],
             date=util.datestr(util.strdate(certs["date"], "%Y-%m-%dT%H:%M:%S")),
             desc=certs["changelog"],
             rev=rev,
             parents=self.mtnrun("parents", rev).splitlines(),
-            branch=certs["branch"])
+            branch=certs["branch"],
+            extra=extra)
 
     def gettags(self):
         tags = {}
         for e in self.mtnrun("tags").split("\n\n"):
             m = self.tag_re.match(e)
             if m:
                 tags[m.group(1)] = m.group(2)
         return tags
 
     def getchangedfiles(self, rev, i):
         # This function is only needed to support --filemap
         # ... and we don't support that
         raise NotImplementedError()
 
     def before(self):
         # Check if we have a new enough version to use automate stdio
         version = 0.0
         try:
             versionstr = self.mtnrunsingle("interface_version")
             version = float(versionstr)
         except Exception:
             raise util.Abort(_("unable to determine mtn automate interface "
                 "version"))
 
         if version >= 12.0:
             self.automatestdio = True
             self.ui.debug("mtn automate version %s - using automate stdio\n" %
                 version)
 
             # launch the long-running automate stdio process
             self.mtnwritefp, self.mtnreadfp = self._run2('automate', 'stdio',
                 '-d', self.path)
             # read the headers
             read = self.mtnreadfp.readline()
             if read != 'format-version: 2\n':
                 raise util.Abort(_('mtn automate stdio header unexpected: %s')
                     % read)
             while read != '\n':
                 read = self.mtnreadfp.readline()
                 if not read:
                     raise util.Abort(_("failed to reach end of mtn automate "
                         "stdio headers"))
         else:
             self.ui.debug("mtn automate version %s - not using automate stdio "
                 "(automate >= 12.0 - mtn >= 0.46 is needed)\n" % version)
 
     def after(self):
         if self.automatestdio:
             self.mtnwritefp.close()
             self.mtnwritefp = None
             self.mtnreadfp.close()
             self.mtnreadfp = None
 

tests/test-convert-mtn.t

@@ -1,357 +1,368
 
   $ "$TESTDIR/hghave" mtn || exit 80
 
 Monotone directory is called .monotone on *nix and monotone
 on Windows. Having a variable here ease test patching.
 
   $ mtndir=.monotone
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "convert=" >> $HGRCPATH
   $ echo 'graphlog =' >> $HGRCPATH
 
 Windows version of monotone home
 
   $ APPDATA=$HOME; export APPDATA
 
 tedious monotone keys configuration
 The /dev/null redirection is necessary under Windows, or
 it complains about home directory permissions
 
   $ mtn --quiet genkey [e-mail] 1>/dev/null 2>&1 <<EOF
   > passphrase
   > passphrase
   > EOF
   $ cat >> $HOME/$mtndir/monotonerc <<EOF
   > function get_passphrase(keypair_id)
   >     return "passphrase"
   > end
   > EOF
 
 create monotone repository
 
   $ mtn db init --db=repo.mtn
   $ mtn --db=repo.mtn --branch=com.selenic.test setup workingdir
   $ cd workingdir
   $ echo a > a
   $ mkdir dir
   $ echo b > dir/b
   $ echo d > dir/d
   $ python -c 'file("bin", "wb").write("a\\x00b")'
   $ echo c > c
   $ mtn add a dir/b dir/d c bin
   mtn: adding a to workspace manifest
   mtn: adding bin to workspace manifest
   mtn: adding c to workspace manifest
   mtn: adding dir to workspace manifest
   mtn: adding dir/b to workspace manifest
   mtn: adding dir/d to workspace manifest
   $ mtn ci -m initialize
   mtn: beginning commit on branch 'com.selenic.test'
   mtn: committed revision 0f6e5e4f2e7d2a8ef312408f57618abf026afd90
 
 update monotone working directory
 
   $ mtn mv a dir/a
   mtn: skipping dir, already accounted for in workspace
   mtn: renaming a to dir/a in workspace manifest
   $ echo a >> dir/a
   $ echo b >> dir/b
   $ mtn drop c
   mtn: dropping c from workspace manifest
   $ python -c 'file("bin", "wb").write("b\\x00c")'
   $ mtn ci -m update1
   mtn: beginning commit on branch 'com.selenic.test'
   mtn: committed revision 51d0a982464573a2a2cf5ee2c9219c652aaebeff
   $ cd ..
 
 convert once
 
   $ hg convert -s mtn repo.mtn
   assuming destination repo.mtn-hg
   initializing destination repo.mtn-hg repository
   scanning source...
   sorting...
   converting...
   1 initialize
   0 update1
   $ cd workingdir
   $ echo e > e
   $ mtn add e
   mtn: adding e to workspace manifest
   $ mtn drop dir/b
   mtn: dropping dir/b from workspace manifest
   $ mtn mv bin bin2
   mtn: renaming bin to bin2 in workspace manifest
   $ mtn ci -m 'update2 "with" quotes'
   mtn: beginning commit on branch 'com.selenic.test'
   mtn: committed revision ebe58335d85d8cb176b6d0a12be04f5314b998da
 
 test directory move
 
   $ mkdir -p dir1/subdir1
   $ mkdir -p dir1/subdir2_other
   $ echo file1 > dir1/subdir1/file1
   $ echo file2 > dir1/subdir2_other/file1
   $ mtn add dir1/subdir1/file1 dir1/subdir2_other/file1
   mtn: adding dir1 to workspace manifest
   mtn: adding dir1/subdir1 to workspace manifest
   mtn: adding dir1/subdir1/file1 to workspace manifest
   mtn: adding dir1/subdir2_other to workspace manifest
   mtn: adding dir1/subdir2_other/file1 to workspace manifest
   $ mtn ci -m createdir1
   mtn: beginning commit on branch 'com.selenic.test'
   mtn: committed revision a8d62bc04fee4d2936d28e98bbcc81686dd74306
   $ mtn rename dir1/subdir1 dir1/subdir2
   mtn: skipping dir1, already accounted for in workspace
   mtn: renaming dir1/subdir1 to dir1/subdir2 in workspace manifest
   $ mtn ci -m movedir1
   mtn: beginning commit on branch 'com.selenic.test'
   mtn: committed revision 2c3d241bbbfe538b1b51d910f5676407e3f4d3a6
 
 test subdirectory move
 
   $ mtn mv dir dir2
   mtn: renaming dir to dir2 in workspace manifest
   $ echo newfile > dir2/newfile
   $ mtn drop dir2/d
   mtn: dropping dir2/d from workspace manifest
   $ mtn add dir2/newfile
   mtn: adding dir2/newfile to workspace manifest
   $ mtn ci -m movedir
   mtn: beginning commit on branch 'com.selenic.test'
   mtn: committed revision fdb5a02dae8bfce3a79b3393680af471016e1b4c
 
 Test directory removal with empty directory
 
   $ mkdir dir2/dir
   $ mkdir dir2/dir/subdir
   $ echo f > dir2/dir/subdir/f
   $ mkdir dir2/dir/emptydir
   $ mtn add --quiet -R dir2/dir
   $ mtn ci -m emptydir
   mtn: beginning commit on branch 'com.selenic.test'
   mtn: committed revision 8bbf76d717001d24964e4604739fdcd0f539fc88
   $ mtn drop -R dir2/dir
   mtn: dropping dir2/dir/subdir/f from workspace manifest
   mtn: dropping dir2/dir/subdir from workspace manifest
   mtn: dropping dir2/dir/emptydir from workspace manifest
   mtn: dropping dir2/dir from workspace manifest
   $ mtn ci -m dropdirectory
   mtn: beginning commit on branch 'com.selenic.test'
   mtn: committed revision 2323d4bc324e6c82628dc04d47a9fd32ad24e322
 
 test directory and file move
 
   $ mkdir -p dir3/d1
   $ echo a > dir3/a
   $ mtn add dir3/a dir3/d1
   mtn: adding dir3 to workspace manifest
   mtn: adding dir3/a to workspace manifest
   mtn: adding dir3/d1 to workspace manifest
   $ mtn ci -m dirfilemove
   mtn: beginning commit on branch 'com.selenic.test'
   mtn: committed revision 47b192f720faa622f48c68d1eb075b26d405aa8b
   $ mtn mv dir3/a dir3/d1/a
   mtn: skipping dir3/d1, already accounted for in workspace
   mtn: renaming dir3/a to dir3/d1/a in workspace manifest
   $ mtn mv dir3/d1 dir3/d2
   mtn: skipping dir3, already accounted for in workspace
   mtn: renaming dir3/d1 to dir3/d2 in workspace manifest
   $ mtn ci -m dirfilemove2
   mtn: beginning commit on branch 'com.selenic.test'
   mtn: committed revision 8b543a400d3ee7f6d4bb1835b9b9e3747c8cb632
 
 test directory move into another directory move
 
   $ mkdir dir4
   $ mkdir dir5
   $ echo a > dir4/a
   $ mtn add dir4/a dir5
   mtn: adding dir4 to workspace manifest
   mtn: adding dir4/a to workspace manifest
   mtn: adding dir5 to workspace manifest
   $ mtn ci -m dirdirmove
   mtn: beginning commit on branch 'com.selenic.test'
   mtn: committed revision 466e0b2afc7a55aa2b4ab2f57cb240bb6cd66fc7
   $ mtn mv dir5 dir6
   mtn: renaming dir5 to dir6 in workspace manifest
   $ mtn mv dir4 dir6/dir4
   mtn: skipping dir6, already accounted for in workspace
   mtn: renaming dir4 to dir6/dir4 in workspace manifest
   $ mtn ci -m dirdirmove2
   mtn: beginning commit on branch 'com.selenic.test'
   mtn: committed revision 3d1f77ebad0c23a5d14911be3b670f990991b749
 
 test diverging directory moves
 
   $ mkdir -p dir7/dir9/dir8
   $ echo a > dir7/dir9/dir8/a
   $ echo b > dir7/dir9/b
   $ echo c > dir7/c
   $ mtn add -R dir7
   mtn: adding dir7 to workspace manifest
   mtn: adding dir7/c to workspace manifest
   mtn: adding dir7/dir9 to workspace manifest
   mtn: adding dir7/dir9/b to workspace manifest
   mtn: adding dir7/dir9/dir8 to workspace manifest
   mtn: adding dir7/dir9/dir8/a to workspace manifest
   $ mtn ci -m divergentdirmove
   mtn: beginning commit on branch 'com.selenic.test'
   mtn: committed revision 08a08511f18b428d840199b062de90d0396bc2ed
   $ mtn mv dir7 dir7-2
   mtn: renaming dir7 to dir7-2 in workspace manifest
   $ mtn mv dir7-2/dir9 dir9-2
   mtn: renaming dir7-2/dir9 to dir9-2 in workspace manifest
   $ mtn mv dir9-2/dir8 dir8-2
   mtn: renaming dir9-2/dir8 to dir8-2 in workspace manifest
   $ mtn ci -m divergentdirmove2
   mtn: beginning commit on branch 'com.selenic.test'
   mtn: committed revision 4a736634505795f17786fffdf2c9cbf5b11df6f6
+
+test suspending (closing a branch)
+
+  $ mtn suspend 4a736634505795f17786fffdf2c9cbf5b11df6f6 2> /dev/null
   $ cd ..
 
 convert incrementally
 
   $ hg convert -s mtn repo.mtn
   assuming destination repo.mtn-hg
   scanning source...
   sorting...
   converting...
   11 update2 "with" quotes
   10 createdir1
   9 movedir1
   8 movedir
   7 emptydir
   6 dropdirectory
   5 dirfilemove
   4 dirfilemove2
   3 dirdirmove
   2 dirdirmove2
   1 divergentdirmove
   0 divergentdirmove2
   $ glog()
   > {
   >     hg glog --template '{rev} "{desc|firstline}" files: {files}\n' "$@"
   > }
   $ cd repo.mtn-hg
   $ hg up -C
   11 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ glog
   @  13 "divergentdirmove2" files: dir7-2/c dir7/c dir7/dir9/b dir7/dir9/dir8/a dir8-2/a dir9-2/b
   |
   o  12 "divergentdirmove" files: dir7/c dir7/dir9/b dir7/dir9/dir8/a
   |
   o  11 "dirdirmove2" files: dir4/a dir6/dir4/a
   |
   o  10 "dirdirmove" files: dir4/a
   |
   o  9 "dirfilemove2" files: dir3/a dir3/d2/a
   |
   o  8 "dirfilemove" files: dir3/a
   |
   o  7 "dropdirectory" files: dir2/dir/subdir/f
   |
   o  6 "emptydir" files: dir2/dir/subdir/f
   |
   o  5 "movedir" files: dir/a dir/d dir2/a dir2/newfile
   |
   o  4 "movedir1" files: dir1/subdir1/file1 dir1/subdir2/file1
   |
   o  3 "createdir1" files: dir1/subdir1/file1 dir1/subdir2_other/file1
   |
   o  2 "update2 "with" quotes" files: bin bin2 dir/b e
   |
   o  1 "update1" files: a bin c dir/a dir/b
   |
   o  0 "initialize" files: a bin c dir/b dir/d
   
 
 manifest
 
   $ hg manifest
   bin2
   dir1/subdir2/file1
   dir1/subdir2_other/file1
   dir2/a
   dir2/newfile
   dir3/d2/a
   dir6/dir4/a
   dir7-2/c
   dir8-2/a
   dir9-2/b
   e
 
 contents
 
   $ cat dir2/a
   a
   a
   $ test -d dir2/dir && echo 'removed dir2/dir is still there!'
   [1]
 
 file move
 
   $ hg log -v -C -r 1 | grep copies
   copies:      dir/a (a)
 
 check directory move
 
   $ hg manifest -r 4
   bin2
   dir/a
   dir/d
   dir1/subdir2/file1
   dir1/subdir2_other/file1
   e
   $ test -d dir1/subdir2 || echo 'new dir1/subdir2 does not exist!'
   $ test -d dir1/subdir1 && echo 'renamed dir1/subdir1 is still there!'
   [1]
   $ hg log -v -C -r 4 | grep copies
   copies:      dir1/subdir2/file1 (dir1/subdir1/file1)
 
 check file remove with directory move
 
   $ hg manifest -r 5
   bin2
   dir1/subdir2/file1
   dir1/subdir2_other/file1
   dir2/a
   dir2/newfile
   e
 
 check file move with directory move
 
   $ hg manifest -r 9
   bin2
   dir1/subdir2/file1
   dir1/subdir2_other/file1
   dir2/a
   dir2/newfile
   dir3/d2/a
   e
 
 check file directory directory move
 
   $ hg manifest -r 11
   bin2
   dir1/subdir2/file1
   dir1/subdir2_other/file1
   dir2/a
   dir2/newfile
   dir3/d2/a
   dir6/dir4/a
   e
 
 check divergent directory moves
 
   $ hg manifest -r 13
   bin2
   dir1/subdir2/file1
   dir1/subdir2_other/file1
   dir2/a
   dir2/newfile
   dir3/d2/a
   dir6/dir4/a
   dir7-2/c
   dir8-2/a
   dir9-2/b
   e
+
+check branch closing
+
+  $ hg branches -a
+  $ hg branches -c
+  com.selenic.test              13:* (closed) (glob)
+