Merge lp:~jelmer/ubuntu/natty/bzr/sru-2.3.4 into lp:ubuntu/natty/bzr

[Jelmer Vernooij]

bzr (2.3.4-0ubuntu1) natty-proposed; urgency=low

  * New upstream release.
   + Fix bzr version number in deprecation warnings. LP: #794960
   + Prevent write attemps on remote branch during "bzr up". LP: #786980
   + Fix conflict handling when two trees involved in a merge have different
     root ids. LP: #805809

 -- Jelmer Vernooij <email address hidden> Thu, 14 Jul 2011 21:12:58 +0200

bzr (2.3.3-0ubuntu1) natty-proposed; urgency=low

  * New upstream release.
   + Fixes deprecation warning on newer versions of Python. LP: #760435
   + Stops 'bzr push' from copying entire repository if a .bzr directory is
     present without a branch. LP: #465517
   + Fixes undefined local variable error when waiting for lock. LP: #733136
   + Fixes lock contention issues pushing to a bound branch. LP: #733350
   + Transfers less data creating a new stacked branch. LP: #737234
   + Several fixes to the test suite, making it more robust. LP: #654733,
      LP: #751824
   + 'bzr merge --pull --preview' actually shows a preview rather than
     actually merging. LP: #760152
   + bzr smart server now supports UTF-8 user names. LP: #659763
   + user identity can now be set based on username and /etc/mailname, not
     requiring it to be set manually. LP: #616878
   + stacking is now fully transitive. LP: #715000
   + makes in-terminal crash report of plugins much shorter. LP: #716389

 -- Jelmer Vernooij <email address hidden> Wed, 08 Jun 2011 13:58:00 +0100

[Martin Pool (mbp)]

I have read the news and metadata parts of the diff, and skimmed the body of the diff. (The diff is pretty long mostly because of mechanical updates to work with Python upstream deprecations.) I think this is safe and appropriate to go into natty-proposed.

review: Approve

[Martin Pool (mbp)]

The package based on this is now uploaded and waiting in https://launchpad.net/ubuntu/natty/+queue?queue_state=1

=== modified file 'Makefile'
--- Makefile	2010-11-05 23:21:04 +0000
+++ Makefile	2011-07-14 21:01:48 +0000
@@ -42,7 +42,7 @@
 	set -e
 	# Generate a stream for PQM to watch.
 	-$(RM) -f selftest.log
-	$(PYTHON) -Werror -O ./bzr selftest --subunit $(tests) | tee selftest.log
+	$(PYTHON) -Werror -Wignore::ImportWarning -O ./bzr selftest --subunit $(tests) | tee selftest.log
 	# An empty log file should catch errors in the $(PYTHON)
 	# command above (the '|' swallow any errors since 'make'
 	# sees the 'tee' exit code for the whole line

=== modified file 'bzr'
--- bzr	2011-03-13 15:08:21 +0000
+++ bzr	2011-07-14 21:01:48 +0000
@@ -1,6 +1,6 @@
 #! /usr/bin/env python
 
-# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Canonical Ltd
+# Copyright (C) 2005-2011 Canonical Ltd
 #
 # 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
@@ -23,7 +23,7 @@
 import warnings
 
 # update this on each release
-_script_version = (2, 3, 1)
+_script_version = (2, 3, 4)
 
 try:
     version_info = sys.version_info

=== modified file 'bzrlib/__init__.py'
--- bzrlib/__init__.py	2011-03-13 15:08:21 +0000
+++ bzrlib/__init__.py	2011-07-14 21:01:48 +0000
@@ -43,7 +43,7 @@
 IGNORE_FILENAME = ".bzrignore"
 
 
-__copyright__ = "Copyright 2005-2010 Canonical Ltd."
+__copyright__ = "Copyright 2005-2011 Canonical Ltd."
 
 # same format as sys.version_info: "A tuple containing the five components of
 # the version number: major, minor, micro, releaselevel, and serial. All
@@ -52,7 +52,7 @@
 # Python version 2.0 is (2, 0, 0, 'final', 0)."  Additionally we use a
 # releaselevel of 'dev' for unreleased under-development code.
 
-version_info = (2, 3, 1, 'final', 0)
+version_info = (2, 3, 4, 'final', 0)
 
 # API compatibility version
 api_minimum_version = (2, 3, 0)

=== modified file 'bzrlib/branch.py'
--- bzrlib/branch.py	2011-01-21 22:08:19 +0000
+++ bzrlib/branch.py	2011-07-14 21:01:48 +0000
@@ -71,8 +71,9 @@
     :ivar base:
         Base directory/url of the branch; using control_url and
         control_transport is more standardized.
-
-    hooks: An instance of BranchHooks.
+    :ivar hooks: An instance of BranchHooks.
+    :ivar _master_branch_cache: cached result of get_master_branch, see
+        _clear_cached_state.
     """
     # this is really an instance variable - FIXME move it there
     # - RBC 20060112
@@ -94,6 +95,7 @@
         self._partial_revision_history_cache = []
         self._tags_bytes = None
         self._last_revision_info_cache = None
+        self._master_branch_cache = None
         self._merge_sorted_revisions_cache = None
         self._open_hook()
         hooks = Branch.hooks['open']
@@ -926,6 +928,7 @@
         self._revision_history_cache = None
         self._revision_id_to_revno_cache = None
         self._last_revision_info_cache = None
+        self._master_branch_cache = None
         self._merge_sorted_revisions_cache = None
         self._partial_revision_history_cache = []
         self._partial_revision_id_to_revno_cache = {}
@@ -2671,8 +2674,7 @@
             target.update_revisions(self, stop_revision,
                 overwrite=overwrite, graph=graph)
         if self._push_should_merge_tags():
-            result.tag_conflicts = self.tags.merge_to(target.tags,
-                overwrite)
+            result.tag_conflicts = self.tags.merge_to(target.tags, overwrite)
         result.new_revno, result.new_revid = target.last_revision_info()
         return result
 
@@ -2723,12 +2725,13 @@
         """Return the branch we are bound to.
 
         :return: Either a Branch, or None
-
-        This could memoise the branch, but if thats done
-        it must be revalidated on each new lock.
-        So for now we just don't memoise it.
-        # RBC 20060304 review this decision.
         """
+        if self._master_branch_cache is None:
+            self._master_branch_cache = self._get_master_branch(
+                possible_transports)
+        return self._master_branch_cache
+
+    def _get_master_branch(self, possible_transports):
         bound_loc = self.get_bound_location()
         if not bound_loc:
             return None
@@ -2745,6 +2748,7 @@
 
         :param location: URL to the target branch
         """
+        self._master_branch_cache = None
         if location:
             self._transport.put_bytes('bound', location+'\n',
                 mode=self.bzrdir._get_file_mode())
@@ -3002,6 +3006,7 @@
 
     def set_bound_location(self, location):
         """See Branch.set_push_location."""
+        self._master_branch_cache = None
         result = None
         config = self.get_config()
         if location is None:
@@ -3461,7 +3466,16 @@
         if local and not bound_location:
             raise errors.LocalRequiresBoundBranch()
         master_branch = None
-        source_is_master = (self.source.user_url == bound_location)
+        source_is_master = False
+        if bound_location:
+            # bound_location comes from a config file, some care has to be
+            # taken to relate it to source.user_url
+            normalized = urlutils.normalize_url(bound_location)
+            try:
+                relpath = self.source.user_transport.relpath(normalized)
+                source_is_master = (relpath == '')
+            except (errors.PathNotChild, errors.InvalidURL):
+                source_is_master = False
         if not local and bound_location and not source_is_master:
             # not pulling from master, so we need to update master.
             master_branch = self.target.get_master_branch(possible_transports)

=== modified file 'bzrlib/builtins.py'
--- bzrlib/builtins.py	2011-01-21 22:08:19 +0000
+++ bzrlib/builtins.py	2011-07-14 21:01:48 +0000
@@ -2726,7 +2726,7 @@
             bzr ignore "RE:(?!debian/).*"
         
         Ignore everything except the "local" toplevel directory,
-        but always ignore "*~" autosave files, even under local/::
+        but always ignore ``*~`` autosave files, even under local/::
         
             bzr ignore "*"
             bzr ignore "!./local"
@@ -3948,7 +3948,7 @@
             merger.other_rev_id is not None):
             note('Nothing to do.')
             return 0
-        if pull:
+        if pull and not preview:
             if merger.interesting_files is not None:
                 raise errors.BzrCommandError('Cannot pull individual files')
             if (merger.base_rev_id == tree.last_revision()):

=== modified file 'bzrlib/commands.py'
--- bzrlib/commands.py	2011-03-13 15:08:21 +0000
+++ bzrlib/commands.py	2011-07-14 21:01:48 +0000
@@ -514,12 +514,13 @@
         # so we get <https://bugs.launchpad.net/bzr/+bug/249908>.  -- mbp
         # 20090319
         options = option.get_optparser(self.options()).format_option_help()
-        # XXX: According to the spec, ReST option lists actually don't support 
-        # options like --1.9 so that causes syntax errors (in Sphinx at least).
-        # As that pattern always appears in the commands that break, we trap
-        # on that and then format that block of 'format' options as a literal
-        # block.
-        if not plain and options.find('  --1.9  ') != -1:
+        # FIXME: According to the spec, ReST option lists actually don't
+        # support options like --1.14 so that causes syntax errors (in Sphinx
+        # at least).  As that pattern always appears in the commands that
+        # break, we trap on that and then format that block of 'format' options
+        # as a literal block. We use the most recent format still listed so we
+        # don't have to do that too often -- vila 20110514
+        if not plain and options.find('  --1.14  ') != -1:
             options = options.replace(' format:\n', ' format::\n\n', 1)
         if options.startswith('Options:'):
             result += ':' + options

=== modified file 'bzrlib/config.py'
--- bzrlib/config.py	2011-01-21 22:08:19 +0000
+++ bzrlib/config.py	2011-07-14 21:01:48 +0000
@@ -63,6 +63,7 @@
 """
 
 import os
+import string
 import sys
 
 from bzrlib import commands
@@ -271,21 +272,21 @@
         the concrete policy type is checked, and finally
         $EMAIL is examined.
         If no username can be found, errors.NoWhoami exception is raised.
-
-        TODO: Check it's reasonably well-formed.
         """
         v = os.environ.get('BZR_EMAIL')
         if v:
             return v.decode(osutils.get_user_encoding())
-
         v = self._get_user_id()
         if v:
             return v
-
         v = os.environ.get('EMAIL')
         if v:
             return v.decode(osutils.get_user_encoding())
-
+        name, email = _auto_user_id()
+        if name and email:
+            return '%s <%s>' % (name, email)
+        elif email:
+            return email
         raise errors.NoWhoami()
 
     def ensure_username(self):
@@ -1213,6 +1214,86 @@
         return os.path.expanduser('~/.cache')
 
 
+def _get_default_mail_domain():
+    """If possible, return the assumed default email domain.
+
+    :returns: string mail domain, or None.
+    """
+    if sys.platform == 'win32':
+        # No implementation yet; patches welcome
+        return None
+    try:
+        f = open('/etc/mailname')
+    except (IOError, OSError), e:
+        return None
+    try:
+        domain = f.read().strip()
+        return domain
+    finally:
+        f.close()
+
+
+def _auto_user_id():
+    """Calculate automatic user identification.
+
+    :returns: (realname, email), either of which may be None if they can't be
+    determined.
+
+    Only used when none is set in the environment or the id file.
+
+    This only returns an email address if we can be fairly sure the 
+    address is reasonable, ie if /etc/mailname is set on unix.
+
+    This doesn't use the FQDN as the default domain because that may be 
+    slow, and it doesn't use the hostname alone because that's not normally 
+    a reasonable address.
+    """
+    if sys.platform == 'win32':
+        # No implementation to reliably determine Windows default mail
+        # address; please add one.
+        return None, None
+
+    default_mail_domain = _get_default_mail_domain()
+    if not default_mail_domain:
+        return None, None
+
+    import pwd
+    uid = os.getuid()
+    try:
+        w = pwd.getpwuid(uid)
+    except KeyError:
+        mutter('no passwd entry for uid %d?' % uid)
+        return None, None
+
+    # we try utf-8 first, because on many variants (like Linux),
+    # /etc/passwd "should" be in utf-8, and because it's unlikely to give
+    # false positives.  (many users will have their user encoding set to
+    # latin-1, which cannot raise UnicodeError.)
+    try:
+        gecos = w.pw_gecos.decode('utf-8')
+        encoding = 'utf-8'
+    except UnicodeError:
+        try:
+            encoding = osutils.get_user_encoding()
+            gecos = w.pw_gecos.decode(encoding)
+        except UnicodeError, e:
+            mutter("cannot decode passwd entry %s" % w)
+            return None, None
+    try:
+        username = w.pw_name.decode(encoding)
+    except UnicodeError, e:
+        mutter("cannot decode passwd entry %s" % w)
+        return None, None
+
+    comma = gecos.find(',')
+    if comma == -1:
+        realname = gecos
+    else:
+        realname = gecos[:comma]
+
+    return realname, (username + '@' + default_mail_domain)
+
+
 def parse_username(username):
     """Parse e-mail username and return a (name, address) tuple."""
     match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)

=== modified file 'bzrlib/controldir.py'
--- bzrlib/controldir.py	2011-02-03 18:58:06 +0000
+++ bzrlib/controldir.py	2011-07-14 21:01:48 +0000
@@ -503,6 +503,10 @@
         if br_to is None:
             # We have a repository but no branch, copy the revisions, and then
             # create a branch.
+            if revision_id is None:
+                # No revision supplied by the user, default to the branch
+                # revision
+                revision_id = source.last_revision()
             repository_to.fetch(source.repository, revision_id=revision_id)
             br_to = source.clone(self, revision_id=revision_id)
             if source.get_push_location() is None or remember:

=== modified file 'bzrlib/crash.py'
--- bzrlib/crash.py	2010-10-11 02:21:33 +0000
+++ bzrlib/crash.py	2011-07-14 21:01:48 +0000
@@ -1,4 +1,4 @@
-# Copyright (C) 2009, 2010 Canonical Ltd
+# Copyright (C) 2009-2011 Canonical Ltd
 #
 # 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
@@ -84,19 +84,27 @@
     """Report a bug by just printing a message to the user."""
     trace.print_exception(exc_info, err_file)
     err_file.write('\n')
-    err_file.write('bzr %s on python %s (%s)\n' % \
-                       (bzrlib.__version__,
-                        bzrlib._format_version_tuple(sys.version_info),
-                        platform.platform(aliased=1)))
-    err_file.write('arguments: %r\n' % sys.argv)
-    err_file.write(
+    import textwrap
+    def print_wrapped(l):
+        err_file.write(textwrap.fill(l,
+            width=78, subsequent_indent='    ') + '\n')
+    print_wrapped('bzr %s on python %s (%s)\n' % \
+        (bzrlib.__version__,
+        bzrlib._format_version_tuple(sys.version_info),
+        platform.platform(aliased=1)))
+    print_wrapped('arguments: %r\n' % sys.argv)
+    print_wrapped(textwrap.fill(
+        'plugins: ' + plugin.format_concise_plugin_list(),
+        width=78,
+        subsequent_indent='    ',
+        ) + '\n')
+    print_wrapped(
         'encoding: %r, fsenc: %r, lang: %r\n' % (
             osutils.get_user_encoding(), sys.getfilesystemencoding(),
             os.environ.get('LANG')))
-    err_file.write("plugins:\n")
-    err_file.write(_format_plugin_list())
+    # We used to show all the plugins here, but it's too verbose.
     err_file.write(
-        "\n\n"
+        "\n"
         "*** Bazaar has encountered an internal error.  This probably indicates a\n"
         "    bug in Bazaar.  You can help us fix it by filing a bug report at\n"
         "        https://bugs.launchpad.net/bzr/+filebug\n"

=== modified file 'bzrlib/help_topics/en/configuration.txt'
--- bzrlib/help_topics/en/configuration.txt	2011-01-21 22:08:19 +0000
+++ bzrlib/help_topics/en/configuration.txt	2011-07-14 21:01:48 +0000
@@ -19,7 +19,9 @@
 BZR_PROGRESS_BAR
 ~~~~~~~~~~~~~~~~
 
-Override the progress display.  Possible values are "none", "dots", "tty"
+Override the progress display.  Possible values are "none" or "text".  If
+the value is "none" then no progress bar is displayed.  The value "text" draws
+the ordinary command line progress bar.
 
 BZR_SIGQUIT_PDB
 ~~~~~~~~~~~~~~~

=== modified file 'bzrlib/inventory.py'
--- bzrlib/inventory.py	2010-09-20 11:30:28 +0000
+++ bzrlib/inventory.py	2011-07-14 21:01:48 +0000
@@ -1,4 +1,4 @@
-# Copyright (C) 2005-2010 Canonical Ltd
+# Copyright (C) 2005-2011 Canonical Ltd
 #
 # 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
@@ -718,6 +718,14 @@
                 # if we finished all children, pop it off the stack
                 stack.pop()
 
+    def _preload_cache(self):
+        """Populate any caches, we are about to access all items.
+        
+        The default implementation does nothing, because CommonInventory doesn't
+        have a cache.
+        """
+        pass
+    
     def iter_entries_by_dir(self, from_dir=None, specific_file_ids=None,
         yield_parents=False):
         """Iterate over the entries in a directory first order.
@@ -736,6 +744,11 @@
             specific_file_ids = set(specific_file_ids)
         # TODO? Perhaps this should return the from_dir so that the root is
         # yielded? or maybe an option?
+        if from_dir is None and specific_file_ids is None:
+            # They are iterating from the root, and have not specified any
+            # specific entries to look at. All current callers fully consume the
+            # iterator, so we can safely assume we are accessing all entries
+            self._preload_cache()
         if from_dir is None:
             if self.root is None:
                 return
@@ -1390,6 +1403,7 @@
     def __init__(self, search_key_name):
         CommonInventory.__init__(self)
         self._fileid_to_entry_cache = {}
+        self._fully_cached = False
         self._path_to_fileid_cache = {}
         self._search_key_name = search_key_name
         self.root_id = None
@@ -1956,7 +1970,7 @@
 
     def iter_just_entries(self):
         """Iterate over all entries.
-        
+
         Unlike iter_entries(), just the entries are returned (not (path, ie))
         and the order of entries is undefined.
 
@@ -1970,6 +1984,59 @@
                 self._fileid_to_entry_cache[file_id] = ie
             yield ie
 
+    def _preload_cache(self):
+        """Make sure all file-ids are in _fileid_to_entry_cache"""
+        if self._fully_cached:
+            return # No need to do it again
+        # The optimal sort order is to use iteritems() directly
+        cache = self._fileid_to_entry_cache
+        for key, entry in self.id_to_entry.iteritems():
+            file_id = key[0]
+            if file_id not in cache:
+                ie = self._bytes_to_entry(entry)
+                cache[file_id] = ie
+            else:
+                ie = cache[file_id]
+        last_parent_id = last_parent_ie = None
+        pid_items = self.parent_id_basename_to_file_id.iteritems()
+        for key, child_file_id in pid_items:
+            if key == ('', ''): # This is the root
+                if child_file_id != self.root_id:
+                    raise ValueError('Data inconsistency detected.'
+                        ' We expected data with key ("","") to match'
+                        ' the root id, but %s != %s'
+                        % (child_file_id, self.root_id))
+                continue
+            parent_id, basename = key
+            ie = cache[child_file_id]
+            if parent_id == last_parent_id:
+                parent_ie = last_parent_ie
+            else:
+                parent_ie = cache[parent_id]
+            if parent_ie.kind != 'directory':
+                raise ValueError('Data inconsistency detected.'
+                    ' An entry in the parent_id_basename_to_file_id map'
+                    ' has parent_id {%s} but the kind of that object'
+                    ' is %r not "directory"' % (parent_id, parent_ie.kind))
+            if parent_ie._children is None:
+                parent_ie._children = {}
+            basename = basename.decode('utf-8')
+            if basename in parent_ie._children:
+                existing_ie = parent_ie._children[basename]
+                if existing_ie != ie:
+                    raise ValueError('Data inconsistency detected.'
+                        ' Two entries with basename %r were found'
+                        ' in the parent entry {%s}'
+                        % (basename, parent_id))
+            if basename != ie.name:
+                raise ValueError('Data inconsistency detected.'
+                    ' In the parent_id_basename_to_file_id map, file_id'
+                    ' {%s} is listed as having basename %r, but in the'
+                    ' id_to_entry map it is %r'
+                    % (child_file_id, basename, ie.name))
+            parent_ie._children[basename] = ie
+        self._fully_cached = True
+
     def iter_changes(self, basis):
         """Generate a Tree.iter_changes change list between this and basis.
 

=== modified file 'bzrlib/lockdir.py'
--- bzrlib/lockdir.py	2011-01-21 22:08:19 +0000
+++ bzrlib/lockdir.py	2011-07-14 21:01:48 +0000
@@ -537,6 +537,17 @@
             hook(hook_result)
         return result
 
+    def lock_url_for_display(self):
+        """Give a nicely-printable representation of the URL of this lock."""
+        # As local lock urls are correct we display them.
+        # We avoid displaying remote lock urls.
+        lock_url = self.transport.abspath(self.path)
+        if lock_url.startswith('file://'):
+            lock_url = lock_url.split('.bzr/')[0]
+        else:
+            lock_url = ''
+        return lock_url
+
     def wait_lock(self, timeout=None, poll=None, max_attempts=None):
         """Wait a certain period for a lock.
 
@@ -566,6 +577,7 @@
         deadline_str = None
         last_info = None
         attempt_count = 0
+        lock_url = self.lock_url_for_display()
         while True:
             attempt_count += 1
             try:
@@ -590,13 +602,6 @@
                 if deadline_str is None:
                     deadline_str = time.strftime('%H:%M:%S',
                                                  time.localtime(deadline))
-                # As local lock urls are correct we display them.
-                # We avoid displaying remote lock urls.
-                lock_url = self.transport.abspath(self.path)
-                if lock_url.startswith('file://'):
-                    lock_url = lock_url.split('.bzr/')[0]
-                else:
-                    lock_url = ''
                 user, hostname, pid, time_ago = formatted_info
                 msg = ('%s lock %s '        # lock_url
                     'held by '              # start

=== modified file 'bzrlib/merge.py'
--- bzrlib/merge.py	2011-01-21 22:08:19 +0000
+++ bzrlib/merge.py	2011-07-14 21:01:48 +0000
@@ -1619,8 +1619,14 @@
                 if other_parent is None or other_name is None:
                     other_path = '<deleted>'
                 else:
-                    parent_path =  fp.get_path(
-                        self.tt.trans_id_file_id(other_parent))
+                    if other_parent == self.other_tree.get_root_id():
+                        # The tree transform doesn't know about the other root,
+                        # so we special case here to avoid a NoFinalPath
+                        # exception
+                        parent_path = ''
+                    else:
+                        parent_path =  fp.get_path(
+                            self.tt.trans_id_file_id(other_parent))
                     other_path = osutils.pathjoin(parent_path, other_name)
                 c = _mod_conflicts.Conflict.factory(
                     'path conflict', path=this_path,

=== modified file 'bzrlib/osutils.py'
--- bzrlib/osutils.py	2011-02-23 14:55:32 +0000
+++ bzrlib/osutils.py	2011-07-14 21:01:48 +0000
@@ -2372,6 +2372,18 @@
     except UnicodeDecodeError:
         raise errors.BzrError("Can't decode username as %s." % \
                 user_encoding)
+    except ImportError, e:
+        if sys.platform != 'win32':
+            raise
+        if str(e) != 'No module named pwd':
+            raise
+        # https://bugs.launchpad.net/bzr/+bug/660174
+        # getpass.getuser() is unable to return username on Windows
+        # if there is no USERNAME environment variable set.
+        # That could be true if bzr is running as a service,
+        # e.g. running `bzr serve` as a service on Windows.
+        # We should not fail with traceback in this case.
+        username = u'UNKNOWN'
     return username
 
 

=== modified file 'bzrlib/plugin.py'
--- bzrlib/plugin.py	2010-09-20 11:30:28 +0000
+++ bzrlib/plugin.py	2011-07-14 21:01:48 +0000
@@ -1,4 +1,4 @@
-# Copyright (C) 2005-2010 Canonical Ltd
+# Copyright (C) 2005-2011 Canonical Ltd
 #
 # 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
@@ -400,6 +400,17 @@
     return result
 
 
+def format_concise_plugin_list():
+    """Return a string holding a concise list of plugins and their version.
+    """
+    items = []
+    for name, a_plugin in sorted(plugins().items()):
+        items.append("%s[%s]" %
+            (name, a_plugin.__version__))
+    return ', '.join(items)
+
+
+
 class PluginsHelpIndex(object):
     """A help index that returns help topics for plugins."""
 

=== modified file 'bzrlib/plugins/launchpad/test_register.py'
--- bzrlib/plugins/launchpad/test_register.py	2011-01-21 22:08:19 +0000
+++ bzrlib/plugins/launchpad/test_register.py	2011-07-14 21:01:48 +0000
@@ -67,16 +67,19 @@
         """
         class FakeHttpResponse(object):
 
-            def __init__(self, status, reason, headers, body):
+            def __init__(self, status, reason, body):
                 self.status = status
                 self.reason = reason
-                self.headers = headers
                 self.body = body
 
             def read(self, size=-1):
                 return self.body.read(size)
 
-        return FakeHttpResponse(200, 'OK', [], self.getfile())
+            def getheader(self, name, default):
+                # We don't have headers
+                return default
+
+        return FakeHttpResponse(200, 'OK', self.getfile())
 
     def getfile(self):
         """Return a fake file containing the response content."""

=== modified file 'bzrlib/tests/__init__.py'
--- bzrlib/tests/__init__.py	2011-02-03 18:58:06 +0000
+++ bzrlib/tests/__init__.py	2011-07-14 21:01:48 +0000
@@ -1434,7 +1434,7 @@
 
     def assertFileEqual(self, content, path):
         """Fail if path does not contain 'content'."""
-        self.failUnlessExists(path)
+        self.assertPathExists(path)
         f = file(path, 'rb')
         try:
             s = f.read()
@@ -1451,20 +1451,28 @@
             self.assertEqual(expected_docstring, obj.__doc__)
 
     def failUnlessExists(self, path):
+        return self.assertPathExists(path)
+
+    def assertPathExists(self, path):
         """Fail unless path or paths, which may be abs or relative, exist."""
         if not isinstance(path, basestring):
             for p in path:
-                self.failUnlessExists(p)
+                self.assertPathExists(p)
         else:
-            self.failUnless(osutils.lexists(path),path+" does not exist")
+            self.assertTrue(osutils.lexists(path),
+                path + " does not exist")
 
     def failIfExists(self, path):
+        return self.assertPathDoesNotExist(path)
+
+    def assertPathDoesNotExist(self, path):
         """Fail if path or paths, which may be abs or relative, exist."""
         if not isinstance(path, basestring):
             for p in path:
-                self.failIfExists(p)
+                self.assertPathDoesNotExist(p)
         else:
-            self.failIf(osutils.lexists(path),path+" exists")
+            self.assertFalse(osutils.lexists(path),
+                path + " exists")
 
     def _capture_deprecation_warnings(self, a_callable, *args, **kwargs):
         """A helper for callDeprecated and applyDeprecated.

=== modified file 'bzrlib/tests/blackbox/test_bound_branches.py'
--- bzrlib/tests/blackbox/test_bound_branches.py	2010-11-05 23:21:04 +0000
+++ bzrlib/tests/blackbox/test_bound_branches.py	2011-07-14 21:01:48 +0000
@@ -371,7 +371,7 @@
 
         child_tree.merge_from_branch(other_branch)
 
-        self.failUnlessExists('child/c')
+        self.assertPathExists('child/c')
         self.assertEqual([new_rev_id], child_tree.get_parent_ids()[1:])
 
         # Make sure the local branch has the installed revision

=== modified file 'bzrlib/tests/blackbox/test_branch.py'
--- bzrlib/tests/blackbox/test_branch.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/blackbox/test_branch.py	2011-07-14 21:01:48 +0000
@@ -180,7 +180,7 @@
         source.add('file1')
         source.commit('added file')
         out, err = self.run_bzr('branch source target --files-from source')
-        self.failUnlessExists('target/file1')
+        self.assertPathExists('target/file1')
 
     def test_branch_files_from_hardlink(self):
         self.requireFeature(HardlinkFeature)
@@ -209,8 +209,8 @@
     def test_branch_no_tree(self):
         self.example_branch('source')
         self.run_bzr('branch --no-tree source target')
-        self.failIfExists('target/hello')
-        self.failIfExists('target/goodbye')
+        self.assertPathDoesNotExist('target/hello')
+        self.assertPathDoesNotExist('target/goodbye')
 
     def test_branch_into_existing_dir(self):
         self.example_branch('a')
@@ -226,8 +226,8 @@
         # force operation
         self.run_bzr('branch a b --use-existing-dir')
         # check conflicts
-        self.failUnlessExists('b/hello.moved')
-        self.failIfExists('b/godbye.moved')
+        self.assertPathExists('b/hello.moved')
+        self.assertPathDoesNotExist('b/godbye.moved')
         # we can't branch into branch
         out,err = self.run_bzr('branch a b --use-existing-dir', retcode=3)
         self.assertEqual('', out)

=== modified file 'bzrlib/tests/blackbox/test_checkout.py'
--- bzrlib/tests/blackbox/test_checkout.py	2010-09-20 11:30:28 +0000
+++ bzrlib/tests/blackbox/test_checkout.py	2011-07-14 21:01:48 +0000
@@ -69,7 +69,7 @@
         # from 1.
         result = bzrdir.BzrDir.open('checkout')
         self.assertEqual(['1'], result.open_workingtree().get_parent_ids())
-        self.failIfExists('checkout/added_in_2')
+        self.assertPathDoesNotExist('checkout/added_in_2')
 
     def test_checkout_light_dash_r(self):
         out, err = self.run_bzr(['checkout','--lightweight', '-r', '-2',
@@ -78,7 +78,7 @@
         # from 1.
         result = bzrdir.BzrDir.open('checkout')
         self.assertEqual(['1'], result.open_workingtree().get_parent_ids())
-        self.failIfExists('checkout/added_in_2')
+        self.assertPathDoesNotExist('checkout/added_in_2')
 
     def test_checkout_reconstitutes_working_trees(self):
         # doing a 'bzr checkout' in the directory of a branch with no tree
@@ -124,9 +124,9 @@
             cmd.append('--lightweight')
         self.run_bzr('checkout source target')
         # files with unique content should be moved
-        self.failUnlessExists('target/file2.moved')
+        self.assertPathExists('target/file2.moved')
         # files with content matching tree should not be moved
-        self.failIfExists('target/file1.moved')
+        self.assertPathDoesNotExist('target/file1.moved')
 
     def test_checkout_existing_dir_heavy(self):
         self._test_checkout_existing_dir(False)

=== modified file 'bzrlib/tests/blackbox/test_clean_tree.py'
--- bzrlib/tests/blackbox/test_clean_tree.py	2010-09-20 11:30:28 +0000
+++ bzrlib/tests/blackbox/test_clean_tree.py	2011-07-14 21:01:48 +0000
@@ -41,28 +41,28 @@
         self.run_bzr('ignore *.pyc')
         self.touch('name')
         self.touch('name~')
-        self.failUnlessExists('name~')
+        self.assertPathExists('name~')
         self.touch('name.pyc')
         self.run_bzr('clean-tree --force')
-        self.failUnlessExists('name~')
-        self.failIfExists('name')
+        self.assertPathExists('name~')
+        self.assertPathDoesNotExist('name')
         self.touch('name')
         self.run_bzr('clean-tree --detritus --force')
-        self.failUnlessExists('name')
-        self.failIfExists('name~')
-        self.failUnlessExists('name.pyc')
+        self.assertPathExists('name')
+        self.assertPathDoesNotExist('name~')
+        self.assertPathExists('name.pyc')
         self.run_bzr('clean-tree --ignored --force')
-        self.failUnlessExists('name')
-        self.failIfExists('name.pyc')
+        self.assertPathExists('name')
+        self.assertPathDoesNotExist('name.pyc')
         self.run_bzr('clean-tree --unknown --force')
-        self.failIfExists('name')
+        self.assertPathDoesNotExist('name')
         self.touch('name')
         self.touch('name~')
         self.touch('name.pyc')
         self.run_bzr('clean-tree --unknown --ignored --force')
-        self.failIfExists('name')
-        self.failIfExists('name~')
-        self.failIfExists('name.pyc')
+        self.assertPathDoesNotExist('name')
+        self.assertPathDoesNotExist('name~')
+        self.assertPathDoesNotExist('name.pyc')
 
     def test_clean_tree_nested_bzrdir(self):
         # clean-tree should not blindly delete nested bzrdirs (branches)
@@ -73,11 +73,11 @@
         wt3 = self.make_branch_and_tree('bar')
         ignores.tree_ignores_add_patterns(wt1, ['./foo'])
         self.run_bzr(['clean-tree', '--unknown', '--force'])
-        self.failUnlessExists('foo')
-        self.failUnlessExists('bar')
+        self.assertPathExists('foo')
+        self.assertPathExists('bar')
         self.run_bzr(['clean-tree', '--ignored', '--force'])
-        self.failUnlessExists('foo')
-        self.failUnlessExists('bar')
+        self.assertPathExists('foo')
+        self.assertPathExists('bar')
 
     def test_clean_tree_directory(self):
         """Test --directory option"""
@@ -85,6 +85,6 @@
         self.build_tree(['a/added', 'a/unknown', 'a/ignored'])
         tree.add('added')
         self.run_bzr('clean-tree -d a --unknown --ignored --force')
-        self.failIfExists('a/unknown')
-        self.failIfExists('a/ignored')
-        self.failUnlessExists('a/added')
+        self.assertPathDoesNotExist('a/unknown')
+        self.assertPathDoesNotExist('a/ignored')
+        self.assertPathExists('a/added')

=== modified file 'bzrlib/tests/blackbox/test_commit.py'
--- bzrlib/tests/blackbox/test_commit.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/blackbox/test_commit.py	2011-07-14 21:01:48 +0000
@@ -23,6 +23,7 @@
 
 from bzrlib import (
     bzrdir,
+    config,
     osutils,
     ignores,
     msgeditor,
@@ -758,6 +759,9 @@
         self.run_bzr(['add'])
         self.overrideEnv('EMAIL', None)
         self.overrideEnv('BZR_EMAIL', None)
+        # Also, make sure that it's not inferred from mailname.
+        self.overrideAttr(config, '_auto_user_id',
+            lambda: (None, None))
         out, err = self.run_bzr(['commit', '-m', 'initial'], 3)
         self.assertContainsRe(err, 'Unable to determine your name')
 

=== modified file 'bzrlib/tests/blackbox/test_export.py'
--- bzrlib/tests/blackbox/test_export.py	2010-10-11 02:21:33 +0000
+++ bzrlib/tests/blackbox/test_export.py	2011-07-14 21:01:48 +0000
@@ -48,10 +48,10 @@
         self.run_bzr('ignore something')
         tree.commit('1')
 
-        self.failUnless(tree.has_filename('.bzrignore'))
-        self.failUnless(tree.has_filename('.bzrrules'))
-        self.failUnless(tree.has_filename('.bzr-adir'))
-        self.failUnless(tree.has_filename('.bzr-adir/afile'))
+        self.assertTrue(tree.has_filename('.bzrignore'))
+        self.assertTrue(tree.has_filename('.bzrrules'))
+        self.assertTrue(tree.has_filename('.bzr-adir'))
+        self.assertTrue(tree.has_filename('.bzr-adir/afile'))
         self.run_bzr('export test.tar.gz')
         ball = tarfile.open('test.tar.gz')
         # Make sure the tarball contains 'a', but does not contain
@@ -106,11 +106,11 @@
         self.run_bzr('ignore something')
         tree.commit('1')
 
-        self.failUnless(tree.has_filename('.bzrignore'))
-        self.failUnless(tree.has_filename('.bzrrules'))
-        self.failUnless(tree.has_filename('.bzr-adir'))
-        self.failUnless(tree.has_filename('.bzr-adir/afile'))
         self.run_bzr('export test.zip')
+        self.assertTrue(tree.has_filename('.bzrignore'))
+        self.assertTrue(tree.has_filename('.bzrrules'))
+        self.assertTrue(tree.has_filename('.bzr-adir'))
+        self.assertTrue(tree.has_filename('.bzr-adir/afile'))
 
         zfile = zipfile.ZipFile('test.zip')
         # Make sure the zipfile contains 'a', but does not contain
@@ -175,10 +175,10 @@
         self.run_bzr('ignore something')
         tree.commit('1')
 
-        self.failUnless(tree.has_filename('.bzrignore'))
-        self.failUnless(tree.has_filename('.bzrrules'))
-        self.failUnless(tree.has_filename('.bzr-adir'))
-        self.failUnless(tree.has_filename('.bzr-adir/afile'))
+        self.assertTrue(tree.has_filename('.bzrignore'))
+        self.assertTrue(tree.has_filename('.bzrrules'))
+        self.assertTrue(tree.has_filename('.bzr-adir'))
+        self.assertTrue(tree.has_filename('.bzr-adir/afile'))
         self.run_bzr('export direxport')
 
         files = sorted(os.listdir('direxport'))
@@ -221,7 +221,7 @@
         os.chdir('branch')
 
         self.run_bzr('export ../first.tar -r 1')
-        self.failUnless(os.path.isfile('../first.tar'))
+        self.assertTrue(os.path.isfile('../first.tar'))
         tf = tarfile.open('../first.tar')
         try:
             self.assertEqual(['first/hello'], sorted(tf.getnames()))
@@ -230,13 +230,13 @@
             tf.close()
 
         self.run_bzr('export ../first.tar.gz -r 1')
-        self.failUnless(os.path.isfile('../first.tar.gz'))
+        self.assertTrue(os.path.isfile('../first.tar.gz'))
         self.run_bzr('export ../first.tbz2 -r 1')
-        self.failUnless(os.path.isfile('../first.tbz2'))
+        self.assertTrue(os.path.isfile('../first.tbz2'))
         self.run_bzr('export ../first.tar.bz2 -r 1')
-        self.failUnless(os.path.isfile('../first.tar.bz2'))
+        self.assertTrue(os.path.isfile('../first.tar.bz2'))
         self.run_bzr('export ../first.tar.tbz2 -r 1')
-        self.failUnless(os.path.isfile('../first.tar.tbz2'))
+        self.assertTrue(os.path.isfile('../first.tar.tbz2'))
 
         tf = tarfile.open('../first.tar.tbz2', 'r:bz2')
         try:
@@ -257,7 +257,7 @@
         os.chdir('branch')
 
         self.run_bzr('export ../first.zip -r 1')
-        self.failUnlessExists('../first.zip')
+        self.assertPathExists('../first.zip')
         zf = zipfile.ZipFile('../first.zip')
         try:
             self.assertEqual(['first/hello'], sorted(zf.namelist()))

=== modified file 'bzrlib/tests/blackbox/test_init.py'
--- bzrlib/tests/blackbox/test_init.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/blackbox/test_init.py	2011-07-14 21:01:48 +0000
@@ -108,7 +108,7 @@
         # init an existing branch.
         out, err = self.run_bzr('init subdir2', retcode=3)
         self.assertEqual('', out)
-        self.failUnless(err.startswith('bzr: ERROR: Already a branch:'))
+        self.assertTrue(err.startswith('bzr: ERROR: Already a branch:'))
 
     def test_init_branch_quiet(self):
         out, err = self.run_bzr('init -q')
@@ -162,7 +162,7 @@
         self.run_bzr_error(['Parent directory of ../new/tree does not exist'],
                             'init ../new/tree', working_dir='tree')
         self.run_bzr('init ../new/tree --create-prefix', working_dir='tree')
-        self.failUnlessExists('new/tree/.bzr')
+        self.assertPathExists('new/tree/.bzr')
 
     def test_init_default_format_option(self):
         """bzr init should read default format from option default_format"""

=== modified file 'bzrlib/tests/blackbox/test_merge.py'
--- bzrlib/tests/blackbox/test_merge.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/blackbox/test_merge.py	2011-07-14 21:01:48 +0000
@@ -19,8 +19,11 @@
 """Black-box tests for bzr merge.
 """
 
+import doctest
 import os
 
+from testtools import matchers
+
 from bzrlib import (
     branch,
     branchbuilder,
@@ -102,7 +105,7 @@
         # Merging a branch pulls its revision into the tree
         b = branch.Branch.open('../b')
         b_tip = b.last_revision()
-        self.failUnless(a.branch.repository.has_revision(b_tip))
+        self.assertTrue(a.branch.repository.has_revision(b_tip))
         self.assertEqual([a_tip, b_tip], a.get_parent_ids())
         a_tree.revert(backups=False)
         out, err = self.run_bzr('merge -r revno:1:./hello', retcode=3)
@@ -204,12 +207,12 @@
         b_tree.commit(message='Modified a.txt')
         os.chdir('b')
         self.run_bzr('merge ../a/', retcode=1)
-        self.failUnlessExists('sub/a.txt.THIS')
-        self.failUnlessExists('sub/a.txt.BASE')
+        self.assertPathExists('sub/a.txt.THIS')
+        self.assertPathExists('sub/a.txt.BASE')
         os.chdir('../a')
         self.run_bzr('merge ../b/', retcode=1)
-        self.failUnlessExists('sub/a.txt.OTHER')
-        self.failUnlessExists('sub/a.txt.BASE')
+        self.assertPathExists('sub/a.txt.OTHER')
+        self.assertPathExists('sub/a.txt.BASE')
 
     def test_conflict_leaves_base_this_other_files(self):
         tree, other = self.create_conflicting_branches()
@@ -326,14 +329,14 @@
         tree_a.add(['file_1', 'file_2'])
         tree_a.commit('commit 1')
         tree_b = tree_a.bzrdir.sprout('b').open_workingtree()
-        self.failUnlessExists('b/file_1')
+        self.assertPathExists('b/file_1')
         tree_a.rename_one('file_1', 'file_i')
         tree_a.commit('commit 2')
         tree_a.rename_one('file_2', 'file_ii')
         ## os.chdir('b')
         self.run_bzr('merge a --uncommitted -d b')
-        self.failUnlessExists('b/file_1')
-        self.failUnlessExists('b/file_ii')
+        self.assertPathExists('b/file_1')
+        self.assertPathExists('b/file_ii')
         tree_b.revert()
         self.run_bzr_error(('Cannot use --uncommitted and --revision',),
                            'merge /a --uncommitted -r1 -d b')
@@ -347,18 +350,18 @@
         tree_a.add(['file1', 'file2'])
         os.chdir('tree_b')
         self.run_bzr(['merge', '--uncommitted', '../tree_a/file1'])
-        self.failUnlessExists('file1')
-        self.failIfExists('file2')
+        self.assertPathExists('file1')
+        self.assertPathDoesNotExist('file2')
 
     def pullable_branch(self):
         tree_a = self.make_branch_and_tree('a')
-        self.build_tree(['a/file'])
+        self.build_tree_contents([('a/file', 'bar\n')])
         tree_a.add(['file'])
         self.id1 = tree_a.commit('commit 1')
 
         tree_b = self.make_branch_and_tree('b')
         tree_b.pull(tree_a.branch)
-        file('b/file', 'wb').write('foo')
+        self.build_tree_contents([('b/file', 'foo\n')])
         self.id2 = tree_b.commit('commit 2')
 
     def test_merge_pull(self):
@@ -369,6 +372,21 @@
         tree_a = workingtree.WorkingTree.open('.')
         self.assertEqual([self.id2], tree_a.get_parent_ids())
 
+    def test_merge_pull_preview(self):
+        self.pullable_branch()
+        (out, err) = self.run_bzr('merge --pull --preview -d a b')
+        self.assertThat(out, matchers.DocTestMatches(
+"""=== modified file 'file'
+--- file\t...
++++ file\t...
+@@ -1,1 +1,1 @@
+-bar
++foo
+
+""", doctest.ELLIPSIS | doctest.REPORT_UDIFF))
+        tree_a = workingtree.WorkingTree.open('a')
+        self.assertEqual([self.id1], tree_a.get_parent_ids())
+
     def test_merge_kind_change(self):
         tree_a = self.make_branch_and_tree('tree_a')
         self.build_tree_contents([('tree_a/file', 'content_1')])
@@ -408,8 +426,8 @@
         self.write_directive('directive', source.branch, 'target', 'rev2',
                              'rev1')
         out, err = self.run_bzr('merge -d target directive')
-        self.failIfExists('target/a')
-        self.failUnlessExists('target/b')
+        self.assertPathDoesNotExist('target/a')
+        self.assertPathExists('target/b')
         self.assertContainsRe(err, 'Performing cherrypick')
 
     def write_directive(self, filename, source, target, revision_id,
@@ -450,19 +468,19 @@
         branch_b.add('file2')
         branch_b.commit('added file2', rev_id='rev2b')
         branch_b.merge_from_branch(branch_a.branch)
-        self.failUnlessExists('branch_b/file1')
+        self.assertPathExists('branch_b/file1')
         branch_b.commit('merged branch_a', rev_id='rev3b')
 
         # It works if the revid has an interger revno
         self.run_bzr('merge -d target -r revid:rev2a branch_a')
-        self.failUnlessExists('target/file1')
-        self.failIfExists('target/file2')
+        self.assertPathExists('target/file1')
+        self.assertPathDoesNotExist('target/file2')
         target.revert()
 
         # It should work if the revid has no integer revno
         self.run_bzr('merge -d target -r revid:rev2a branch_b')
-        self.failUnlessExists('target/file1')
-        self.failIfExists('target/file2')
+        self.assertPathExists('target/file1')
+        self.assertPathDoesNotExist('target/file2')
 
     def assertDirectoryContent(self, directory, entries, message=''):
         """Assert whether entries (file or directories) exist in a directory.
@@ -603,7 +621,7 @@
         other.add('other_file')
         other.commit('rev1b')
         self.run_bzr('merge -d this other -r0..')
-        self.failUnlessExists('this/other_file')
+        self.assertPathExists('this/other_file')
 
     def test_merge_interactive_unlocks_branch(self):
         this = self.make_branch_and_tree('this')
@@ -621,9 +639,9 @@
             tree.commit("added "+f)
         for context in (".", "", "a"):
             self.run_bzr("merge -r 1..0 " + context)
-            self.failIfExists("a")
+            self.assertPathDoesNotExist("a")
             tree.revert()
-            self.failUnlessExists("a")
+            self.assertPathExists("a")
 
 
 class TestMergeForce(tests.TestCaseWithTransport):

=== modified file 'bzrlib/tests/blackbox/test_mv.py'
--- bzrlib/tests/blackbox/test_mv.py	2010-03-24 22:27:38 +0000
+++ bzrlib/tests/blackbox/test_mv.py	2011-07-14 21:01:48 +0000
@@ -35,10 +35,10 @@
 
     def assertMoved(self,from_path,to_path):
         """Assert that to_path is existing and versioned but from_path not. """
-        self.failIfExists(from_path)
+        self.assertPathDoesNotExist(from_path)
         self.assertNotInWorkingTree(from_path)
 
-        self.failUnlessExists(to_path)
+        self.assertPathExists(to_path)
         self.assertInWorkingTree(to_path)
 
     def test_mv_modes(self):
@@ -119,7 +119,7 @@
 
         os.chdir('sub1/sub2')
         self.run_bzr('mv ../hello.txt .')
-        self.failUnlessExists('./hello.txt')
+        self.assertPathExists('./hello.txt')
 
         os.chdir('..')
         self.run_bzr('mv sub2/hello.txt .')
@@ -229,8 +229,8 @@
             ["^bzr: ERROR: Could not move a => b. b is already versioned\.$"],
             'mv a b')
         #check that nothing changed
-        self.failIfExists('a')
-        self.failUnlessExists('b')
+        self.assertPathDoesNotExist('a')
+        self.assertPathExists('b')
 
     def test_mv_already_moved_file_into_subdir(self):
         """Test bzr mv original_file to versioned_directory/file.
@@ -264,8 +264,8 @@
         self.run_bzr_error(
             ["^bzr: ERROR: Could not move a => a: sub is not versioned\.$"],
             'mv a sub/a')
-        self.failIfExists('a')
-        self.failUnlessExists('sub/a')
+        self.assertPathDoesNotExist('a')
+        self.assertPathExists('sub/a')
 
     def test_mv_already_moved_files_into_subdir(self):
         """Test bzr mv original_files to versioned_directory.
@@ -300,10 +300,10 @@
         self.run_bzr_error(
             ["^bzr: ERROR: Could not move to sub. sub is not versioned\.$"],
             'mv a1 a2 sub')
-        self.failIfExists('a1')
-        self.failUnlessExists('sub/a1')
-        self.failUnlessExists('a2')
-        self.failIfExists('sub/a2')
+        self.assertPathDoesNotExist('a1')
+        self.assertPathExists('sub/a1')
+        self.assertPathExists('a2')
+        self.assertPathDoesNotExist('sub/a2')
 
     def test_mv_already_moved_file_forcing_after(self):
         """Test bzr mv versioned_file to unversioned_file.
@@ -325,8 +325,8 @@
              " \(Use --after to tell bzr about a rename that has already"
              " happened\)$"],
             'mv a b')
-        self.failUnlessExists('a')
-        self.failUnlessExists('b')
+        self.assertPathExists('a')
+        self.assertPathExists('b')
 
     def test_mv_already_moved_file_using_after(self):
         """Test bzr mv --after versioned_file to unversioned_file.
@@ -346,9 +346,9 @@
         self.build_tree(['a']) #touch a
 
         self.run_bzr('mv a b --after')
-        self.failUnlessExists('a')
+        self.assertPathExists('a')
         self.assertNotInWorkingTree('a')#a should be unknown now.
-        self.failUnlessExists('b')
+        self.assertPathExists('b')
         self.assertInWorkingTree('b')
 
     def test_mv_already_moved_files_forcing_after(self):
@@ -375,10 +375,10 @@
              " exist. \(Use --after to tell bzr about a rename that has already"
              " happened\)$"],
             'mv a1 a2 sub')
-        self.failUnlessExists('a1')
-        self.failUnlessExists('a2')
-        self.failUnlessExists('sub/a1')
-        self.failUnlessExists('sub/a2')
+        self.assertPathExists('a1')
+        self.assertPathExists('a2')
+        self.assertPathExists('sub/a1')
+        self.assertPathExists('sub/a2')
 
     def test_mv_already_moved_files_using_after(self):
         """Test bzr mv --after versioned_file to directory/unversioned_file.
@@ -402,10 +402,10 @@
         self.build_tree(['a2']) #touch a2
 
         self.run_bzr('mv a1 a2 sub --after')
-        self.failUnlessExists('a1')
-        self.failUnlessExists('a2')
-        self.failUnlessExists('sub/a1')
-        self.failUnlessExists('sub/a2')
+        self.assertPathExists('a1')
+        self.assertPathExists('a2')
+        self.assertPathExists('sub/a1')
+        self.assertPathExists('sub/a2')
         self.assertInWorkingTree('sub/a1')
         self.assertInWorkingTree('sub/a2')
 
@@ -421,15 +421,15 @@
         osutils.rename('c', 'd')
         # mv a b should work just like it does for already renamed files
         self.run_bzr('mv a b')
-        self.failIfExists('a')
+        self.assertPathDoesNotExist('a')
         self.assertNotInWorkingTree('a')
-        self.failUnlessExists('b')
+        self.assertPathExists('b')
         self.assertInWorkingTree('b')
         # and --after should work, too (technically it's ignored)
         self.run_bzr('mv --after c d')
-        self.failIfExists('c')
+        self.assertPathDoesNotExist('c')
         self.assertNotInWorkingTree('c')
-        self.failUnlessExists('d')
+        self.assertPathExists('d')
         self.assertInWorkingTree('d')
 
     def make_abcd_tree(self):

=== modified file 'bzrlib/tests/blackbox/test_non_ascii.py'
--- bzrlib/tests/blackbox/test_non_ascii.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/blackbox/test_non_ascii.py	2011-07-14 21:01:48 +0000
@@ -161,12 +161,12 @@
     def test_cat_revision(self):
         committer = self.info['committer']
         txt = self.run_bzr_decode('cat-revision -r 1')
-        self.failUnless(committer in txt,
+        self.assertTrue(committer in txt,
                         'failed to find %r in %r' % (committer, txt))
 
         msg = self.info['message']
         txt = self.run_bzr_decode('cat-revision -r 2')
-        self.failUnless(msg in txt, 'failed to find %r in %r' % (msg, txt))
+        self.assertTrue(msg in txt, 'failed to find %r in %r' % (msg, txt))
 
     def test_mkdir(self):
         txt = self.run_bzr_decode(['mkdir', self.info['directory']])
@@ -222,8 +222,8 @@
 
         txt = self.run_bzr_decode(['mv', 'a', fname2])
         self.assertEqual(u'a => %s\n' % fname2, txt)
-        self.failIfExists('a')
-        self.failUnlessExists(fname2)
+        self.assertPathDoesNotExist('a')
+        self.assertPathExists(fname2)
 
         # After 'mv' we need to re-open the working tree
         self.wt = self.wt.bzrdir.open_workingtree()
@@ -240,7 +240,7 @@
         # The rename should still succeed
         newpath = u'%s/%s' % (dirname, fname2)
         txt = self.run_bzr_decode(['mv', newpath, 'a'], encoding='ascii')
-        self.failUnlessExists('a')
+        self.assertPathExists('a')
         self.assertEqual(newpath.encode('ascii', 'replace') + ' => a\n', txt)
 
     def test_branch(self):
@@ -386,7 +386,7 @@
         self.assertEqual(fname+'\n', txt)
 
         txt = self.run_bzr_decode('deleted --show-ids')
-        self.failUnless(txt.startswith(fname))
+        self.assertTrue(txt.startswith(fname))
 
         # Deleted should fail if cannot decode
         # Because it is giving the exact paths
@@ -421,7 +421,7 @@
         self.wt.bzrdir.sprout(url)
 
         txt = self.run_bzr_decode('root', working_dir=dirname)
-        self.failUnless(txt.endswith(dirname+'\n'))
+        self.assertTrue(txt.endswith(dirname+'\n'))
 
         txt = self.run_bzr_decode('root', encoding='ascii', fail=True,
                                   working_dir=dirname)

=== modified file 'bzrlib/tests/blackbox/test_push.py'
--- bzrlib/tests/blackbox/test_push.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/blackbox/test_push.py	2011-07-14 21:01:48 +0000
@@ -135,7 +135,7 @@
         out, err = self.run_bzr('push --no-tree -d push-from push-to')
         self.assertEqual('', out)
         self.assertEqual('Created new branch.\n', err)
-        self.failIfExists('push-to/file')
+        self.assertPathDoesNotExist('push-to/file')
 
     def test_push_new_branch_revision_count(self):
         # bzr push of a branch with revisions to a new location
@@ -199,10 +199,26 @@
         t.commit(allow_pointless=True,
                 message='first commit')
         self.run_bzr('push -d from to-one')
-        self.failUnlessExists('to-one')
+        self.assertPathExists('to-one')
         self.run_bzr('push -d %s %s'
             % tuple(map(urlutils.local_path_to_url, ['from', 'to-two'])))
-        self.failUnlessExists('to-two')
+        self.assertPathExists('to-two')
+
+    def test_push_repository_no_branch_doesnt_fetch_all_revs(self):
+        # See https://bugs.launchpad.net/bzr/+bug/465517
+        target_repo = self.make_repository('target')
+        source = self.make_branch_builder('source')
+        source.start_series()
+        source.build_snapshot('A', None, [
+            ('add', ('', 'root-id', 'directory', None))])
+        source.build_snapshot('B', ['A'], [])
+        source.build_snapshot('C', ['A'], [])
+        source.finish_series()
+        self.run_bzr('push target -d source')
+        self.addCleanup(target_repo.lock_read().unlock)
+        # We should have pushed 'C', but not 'B', since it isn't in the
+        # ancestry
+        self.assertEqual([('A',), ('C',)], sorted(target_repo.revisions.keys()))
 
     def test_push_smart_non_stacked_streaming_acceptance(self):
         self.setup_smart_server_with_call_log()
@@ -308,7 +324,7 @@
                      working_dir='tree')
         new_tree = workingtree.WorkingTree.open('new/tree')
         self.assertEqual(tree.last_revision(), new_tree.last_revision())
-        self.failUnlessExists('new/tree/a')
+        self.assertPathExists('new/tree/a')
 
     def test_push_use_existing(self):
         """'bzr push --use-existing-dir' can push into an existing dir.
@@ -329,7 +345,7 @@
         new_tree = workingtree.WorkingTree.open('target')
         self.assertEqual(tree.last_revision(), new_tree.last_revision())
         # The push should have created target/a
-        self.failUnlessExists('target/a')
+        self.assertPathExists('target/a')
 
     def test_push_use_existing_into_empty_bzrdir(self):
         """'bzr push --use-existing-dir' into a dir with an empty .bzr dir

=== modified file 'bzrlib/tests/blackbox/test_reconfigure.py'
--- bzrlib/tests/blackbox/test_reconfigure.py	2010-09-20 11:30:28 +0000
+++ bzrlib/tests/blackbox/test_reconfigure.py	2011-07-14 21:01:48 +0000
@@ -131,7 +131,7 @@
         tree.add('foo')
         self.run_bzr('reconfigure --with-no-trees --force',
             working_dir='repo/branch')
-        self.failUnlessExists('repo/branch/foo')
+        self.assertPathExists('repo/branch/foo')
         tree = workingtree.WorkingTree.open('repo/branch')
 
     def test_shared_format_to_standalone(self, format=None):

=== modified file 'bzrlib/tests/blackbox/test_remerge.py'
--- bzrlib/tests/blackbox/test_remerge.py	2010-09-20 11:30:28 +0000
+++ bzrlib/tests/blackbox/test_remerge.py	2011-07-14 21:01:48 +0000
@@ -74,8 +74,8 @@
                            'remerge hello --merge-type weave',
                            retcode=1)
 
-        self.failUnlessExists('hello.OTHER')
-        self.failIfExists('question.OTHER')
+        self.assertPathExists('hello.OTHER')
+        self.assertPathDoesNotExist('question.OTHER')
 
         file_id = self.run_bzr('file-id hello')[0]
         self.run_bzr_error(['hello.THIS is not versioned'],
@@ -84,8 +84,8 @@
         self.run_bzr_error(['conflicts encountered'],
                            'remerge --merge-type weave', retcode=1)
 
-        self.failUnlessExists('hello.OTHER')
-        self.failUnless('hello.BASE')
+        self.assertPathExists('hello.OTHER')
+        self.assertTrue('hello.BASE')
         self.assertFalse('|||||||' in conflict_text)
         self.assertFalse('hi world' in conflict_text)
 

=== modified file 'bzrlib/tests/blackbox/test_remove.py'
--- bzrlib/tests/blackbox/test_remove.py	2010-10-11 02:21:33 +0000
+++ bzrlib/tests/blackbox/test_remove.py	2011-07-14 21:01:48 +0000
@@ -53,12 +53,12 @@
         for f in files:
             id=f+_id
             self.assertNotInWorkingTree(f)
-            self.failIfExists(f)
+            self.assertPathDoesNotExist(f)
 
     def assertFilesUnversioned(self, files):
         for f in files:
             self.assertNotInWorkingTree(f)
-            self.failUnlessExists(f)
+            self.assertPathExists(f)
 
     def changeFile(self, file_name):
         f = file(file_name, 'ab')
@@ -80,7 +80,7 @@
         self.assertEqual('', err)
         self.assertEqual('', out)
         self.assertInWorkingTree('foo', tree=tree)
-        self.failUnlessExists('foo')
+        self.assertPathExists('foo')
 
     def test_remove_no_files_specified_missing_dir_and_contents(self):
         tree = self._make_tree_and_add(
@@ -94,9 +94,9 @@
             err)
         # non-missing paths not touched:
         self.assertInWorkingTree('foo', tree=tree)
-        self.failUnlessExists('foo')
+        self.assertPathExists('foo')
         self.assertInWorkingTree('dir', tree=tree)
-        self.failUnlessExists('dir')
+        self.assertPathExists('dir')
         # missing files unversioned
         self.assertNotInWorkingTree('dir/missing', tree=tree)
         self.assertNotInWorkingTree('dir/missing/child', tree=tree)
@@ -120,7 +120,7 @@
         self.assertEqual('removed bar\n', err)
         # non-missing files not touched:
         self.assertInWorkingTree('foo', tree=tree)
-        self.failUnlessExists('foo')
+        self.assertPathExists('foo')
         # missing files unversioned
         self.assertNotInWorkingTree('bar', tree=tree)
 
@@ -135,7 +135,7 @@
         self.assertEqual('removed linkname\n', err)
         # non-missing files not touched:
         self.assertInWorkingTree('foo', tree=tree)
-        self.failUnlessExists('foo')
+        self.assertPathExists('foo')
         # missing files unversioned
         self.assertNotInWorkingTree('linkname', tree=tree)
 
@@ -196,7 +196,7 @@
         self.run_bzr_remove_changed_files(
             ['../a', 'c', '.', '../d'], working_dir='b')
         self.assertNotInWorkingTree(files)
-        self.failIfExists(files)
+        self.assertPathDoesNotExist(files)
 
     def test_remove_keep_unversioned_files(self):
         self.build_tree(files)
@@ -237,10 +237,10 @@
         for f in my_files:
             osutils.delete_any(f)
         self.assertInWorkingTree(files)
-        self.failIfExists(files)
+        self.assertPathDoesNotExist(files)
         self.run_bzr('remove ' + ' '.join(files))
         self.assertNotInWorkingTree(a)
-        self.failIfExists(files)
+        self.assertPathDoesNotExist(files)
 
     def test_remove_non_existing_files(self):
         tree = self._make_tree_and_add([])

=== modified file 'bzrlib/tests/blackbox/test_remove_tree.py'
--- bzrlib/tests/blackbox/test_remove_tree.py	2010-09-20 11:30:28 +0000
+++ bzrlib/tests/blackbox/test_remove_tree.py	2011-07-14 21:01:48 +0000
@@ -31,75 +31,75 @@
         self.build_tree(['branch1/foo'])
         self.tree.add('foo')
         self.tree.commit('1')
-        self.failUnlessExists('branch1/foo')
+        self.assertPathExists('branch1/foo')
 
     # Success modes
 
     def test_remove_tree_original_branch(self):
         os.chdir('branch1')
         self.run_bzr('remove-tree')
-        self.failIfExists('foo')
+        self.assertPathDoesNotExist('foo')
 
     def test_remove_tree_original_branch_explicit(self):
         self.run_bzr('remove-tree branch1')
-        self.failIfExists('branch1/foo')
+        self.assertPathDoesNotExist('branch1/foo')
 
     def test_remove_tree_multiple_branch_explicit(self):
         self.tree.bzrdir.sprout('branch2')
         self.run_bzr('remove-tree branch1 branch2')
-        self.failIfExists('branch1/foo')
-        self.failIfExists('branch2/foo')
+        self.assertPathDoesNotExist('branch1/foo')
+        self.assertPathDoesNotExist('branch2/foo')
 
     def test_remove_tree_sprouted_branch(self):
         self.tree.bzrdir.sprout('branch2')
-        self.failUnlessExists('branch2/foo')
+        self.assertPathExists('branch2/foo')
         os.chdir('branch2')
         self.run_bzr('remove-tree')
-        self.failIfExists('foo')
+        self.assertPathDoesNotExist('foo')
 
     def test_remove_tree_sprouted_branch_explicit(self):
         self.tree.bzrdir.sprout('branch2')
-        self.failUnlessExists('branch2/foo')
+        self.assertPathExists('branch2/foo')
         self.run_bzr('remove-tree branch2')
-        self.failIfExists('branch2/foo')
+        self.assertPathDoesNotExist('branch2/foo')
 
     def test_remove_tree_checkout(self):
         self.tree.branch.create_checkout('branch2', lightweight=False)
-        self.failUnlessExists('branch2/foo')
+        self.assertPathExists('branch2/foo')
         os.chdir('branch2')
         self.run_bzr('remove-tree')
-        self.failIfExists('foo')
+        self.assertPathDoesNotExist('foo')
         os.chdir('..')
-        self.failUnlessExists('branch1/foo')
+        self.assertPathExists('branch1/foo')
 
     def test_remove_tree_checkout_explicit(self):
         self.tree.branch.create_checkout('branch2', lightweight=False)
-        self.failUnlessExists('branch2/foo')
+        self.assertPathExists('branch2/foo')
         self.run_bzr('remove-tree branch2')
-        self.failIfExists('branch2/foo')
-        self.failUnlessExists('branch1/foo')
+        self.assertPathDoesNotExist('branch2/foo')
+        self.assertPathExists('branch1/foo')
 
     # Failure modes
 
     def test_remove_tree_lightweight_checkout(self):
         self.tree.branch.create_checkout('branch2', lightweight=True)
-        self.failUnlessExists('branch2/foo')
+        self.assertPathExists('branch2/foo')
         os.chdir('branch2')
         output = self.run_bzr_error(
             ["You cannot remove the working tree from a lightweight checkout"],
             'remove-tree', retcode=3)
-        self.failUnlessExists('foo')
+        self.assertPathExists('foo')
         os.chdir('..')
-        self.failUnlessExists('branch1/foo')
+        self.assertPathExists('branch1/foo')
 
     def test_remove_tree_lightweight_checkout_explicit(self):
         self.tree.branch.create_checkout('branch2', lightweight=True)
-        self.failUnlessExists('branch2/foo')
+        self.assertPathExists('branch2/foo')
         output = self.run_bzr_error(
             ["You cannot remove the working tree from a lightweight checkout"],
             'remove-tree branch2', retcode=3)
-        self.failUnlessExists('branch2/foo')
-        self.failUnlessExists('branch1/foo')
+        self.assertPathExists('branch2/foo')
+        self.assertPathExists('branch1/foo')
 
     def test_remove_tree_empty_dir(self):
         os.mkdir('branch2')
@@ -109,7 +109,7 @@
 
     def test_remove_tree_repeatedly(self):
         self.run_bzr('remove-tree branch1')
-        self.failIfExists('branch1/foo')
+        self.assertPathDoesNotExist('branch1/foo')
         output = self.run_bzr_error(["No working tree to remove"],
                                     'remove-tree branch1', retcode=3)
 
@@ -127,19 +127,19 @@
         self.build_tree(['branch1/bar'])
         self.tree.add('bar')
         self.run_bzr('remove-tree branch1 --force')
-        self.failIfExists('branch1/foo')
-        self.failUnlessExists('branch1/bar')
+        self.assertPathDoesNotExist('branch1/foo')
+        self.assertPathExists('branch1/bar')
 
     def test_remove_tree_pending_merges(self):
         self.run_bzr(['branch', 'branch1', 'branch2'])
         self.build_tree(['branch1/bar'])
         self.tree.add('bar')
         self.tree.commit('2')
-        self.failUnlessExists('branch1/bar')
+        self.assertPathExists('branch1/bar')
         self.run_bzr(['merge', '../branch1'], working_dir='branch2')
-        self.failUnlessExists('branch2/bar')
+        self.assertPathExists('branch2/bar')
         self.run_bzr(['revert', '.'], working_dir='branch2')
-        self.failIfExists('branch2/bar')
+        self.assertPathDoesNotExist('branch2/bar')
         output = self.run_bzr_error(["Working tree .* has uncommitted changes"],
                                     'remove-tree branch2', retcode=3)
 
@@ -148,14 +148,14 @@
         self.build_tree(['branch1/bar'])
         self.tree.add('bar')
         self.tree.commit('2')
-        self.failUnlessExists('branch1/bar')
+        self.assertPathExists('branch1/bar')
         self.run_bzr(['merge', '../branch1'], working_dir='branch2')
-        self.failUnlessExists('branch2/bar')
+        self.assertPathExists('branch2/bar')
         self.run_bzr(['revert', '.'], working_dir='branch2')
-        self.failIfExists('branch2/bar')
+        self.assertPathDoesNotExist('branch2/bar')
         self.run_bzr('remove-tree branch2 --force')
-        self.failIfExists('branch2/foo')
-        self.failIfExists('branch2/bar')
+        self.assertPathDoesNotExist('branch2/foo')
+        self.assertPathDoesNotExist('branch2/bar')
 
     def test_remove_tree_shelved_changes(self):
         # https://bugs.launchpad.net/bzr/+bug/586639

=== modified file 'bzrlib/tests/blackbox/test_revert.py'
--- bzrlib/tests/blackbox/test_revert.py	2010-09-20 11:30:28 +0000
+++ bzrlib/tests/blackbox/test_revert.py	2011-07-14 21:01:48 +0000
@@ -93,17 +93,17 @@
         """Test that revert DIRECTORY does what's expected"""
         self._prepare_rename_mod_tree()
         self.run_bzr('revert a')
-        self.failUnlessExists('a/b')
-        self.failUnlessExists('a/d')
-        self.failIfExists('a/g')
+        self.assertPathExists('a/b')
+        self.assertPathExists('a/d')
+        self.assertPathDoesNotExist('a/g')
         self.expectFailure(
             "j is in the delta revert applies because j was renamed too",
-            self.failUnlessExists, 'j')
-        self.failUnlessExists('h')
+            self.assertPathExists, 'j')
+        self.assertPathExists('h')
         self.run_bzr('revert f')
-        self.failIfExists('j')
-        self.failIfExists('h')
-        self.failUnlessExists('a/d/e')
+        self.assertPathDoesNotExist('j')
+        self.assertPathDoesNotExist('h')
+        self.assertPathExists('a/d/e')
 
     def test_revert_chatter(self):
         self._prepare_rename_mod_tree()
@@ -148,7 +148,7 @@
             self.run_bzr('commit -m f')
             os.unlink('symlink')
             self.run_bzr('revert')
-            self.failUnlessExists('symlink')
+            self.assertPathExists('symlink')
             os.unlink('symlink')
             os.symlink('a-different-path', 'symlink')
             self.run_bzr('revert')

=== modified file 'bzrlib/tests/blackbox/test_rmbranch.py'
--- bzrlib/tests/blackbox/test_rmbranch.py	2010-09-20 11:30:28 +0000
+++ bzrlib/tests/blackbox/test_rmbranch.py	2011-07-14 21:01:48 +0000
@@ -42,8 +42,8 @@
         self.run_bzr('rmbranch a')
         dir = bzrdir.BzrDir.open('a')
         self.assertFalse(dir.has_branch())
-        self.failUnlessExists('a/hello')
-        self.failUnlessExists('a/goodbye')
+        self.assertPathExists('a/hello')
+        self.assertPathExists('a/goodbye')
 
     def test_no_branch(self):
         # No branch in the current directory. 

=== modified file 'bzrlib/tests/blackbox/test_shared_repository.py'
--- bzrlib/tests/blackbox/test_shared_repository.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/blackbox/test_shared_repository.py	2011-07-14 21:01:48 +0000
@@ -88,7 +88,7 @@
         cdir = BzrDir.open('a/c')
         cdir.open_branch()
         self.assertRaises(errors.NoRepositoryPresent, cdir.open_repository)
-        self.failUnlessExists('a/c/hello')
+        self.assertPathExists('a/c/hello')
         cdir.open_workingtree()
 
     def test_trees_default(self):

=== modified file 'bzrlib/tests/blackbox/test_shelve.py'
--- bzrlib/tests/blackbox/test_shelve.py	2010-11-05 23:21:04 +0000
+++ bzrlib/tests/blackbox/test_shelve.py	2011-07-14 21:01:48 +0000
@@ -72,7 +72,7 @@
         self.build_tree(['file'])
         tree.add('file')
         self.run_bzr('shelve --all --destroy')
-        self.failIfExists('file')
+        self.assertPathDoesNotExist('file')
         self.assertIs(None, tree.get_shelf_manager().last_shelf())
 
     def test_unshelve_keep(self):

=== modified file 'bzrlib/tests/blackbox/test_switch.py'
--- bzrlib/tests/blackbox/test_switch.py	2010-09-20 11:30:28 +0000
+++ bzrlib/tests/blackbox/test_switch.py	2011-07-14 21:01:48 +0000
@@ -149,17 +149,17 @@
         tree = self._create_sample_tree()
         checkout = tree.branch.create_checkout('checkout', lightweight=True)
         self.run_bzr(['switch', 'branch-1', '-r1'], working_dir='checkout')
-        self.failUnlessExists('checkout/file-1')
-        self.failIfExists('checkout/file-2')
+        self.assertPathExists('checkout/file-1')
+        self.assertPathDoesNotExist('checkout/file-2')
 
     def test_switch_only_revision(self):
         tree = self._create_sample_tree()
         checkout = tree.branch.create_checkout('checkout', lightweight=True)
-        self.failUnlessExists('checkout/file-1')
-        self.failUnlessExists('checkout/file-2')
+        self.assertPathExists('checkout/file-1')
+        self.assertPathExists('checkout/file-2')
         self.run_bzr(['switch', '-r1'], working_dir='checkout')
-        self.failUnlessExists('checkout/file-1')
-        self.failIfExists('checkout/file-2')
+        self.assertPathExists('checkout/file-1')
+        self.assertPathDoesNotExist('checkout/file-2')
         # Check that we don't accept a range
         self.run_bzr_error(
             ['bzr switch --revision takes exactly one revision identifier'],

=== modified file 'bzrlib/tests/blackbox/test_too_much.py'
--- bzrlib/tests/blackbox/test_too_much.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/blackbox/test_too_much.py	2011-07-14 21:01:48 +0000
@@ -88,7 +88,7 @@
             self.run_bzr('commit -m f')
             os.unlink('symlink')
             self.run_bzr('revert')
-            self.failUnlessExists('symlink')
+            self.assertPathExists('symlink')
             os.unlink('symlink')
             os.symlink('a-different-path', 'symlink')
             self.run_bzr('revert')
@@ -133,9 +133,9 @@
 
         os.chdir('../a')
         out = self.run_bzr('pull --verbose ../b')[0]
-        self.failIfEqual(out.find('Added Revisions:'), -1)
-        self.failIfEqual(out.find('message:\n  added b'), -1)
-        self.failIfEqual(out.find('added b'), -1)
+        self.assertNotEqual(out.find('Added Revisions:'), -1)
+        self.assertNotEqual(out.find('message:\n  added b'), -1)
+        self.assertNotEqual(out.find('added b'), -1)
 
         # Check that --overwrite --verbose prints out the removed entries
         self.run_bzr('commit -m foo --unchanged')
@@ -145,17 +145,17 @@
         out = self.run_bzr('pull --overwrite --verbose ../a')[0]
 
         remove_loc = out.find('Removed Revisions:')
-        self.failIfEqual(remove_loc, -1)
+        self.assertNotEqual(remove_loc, -1)
         added_loc = out.find('Added Revisions:')
-        self.failIfEqual(added_loc, -1)
+        self.assertNotEqual(added_loc, -1)
 
         removed_message = out.find('message:\n  baz')
-        self.failIfEqual(removed_message, -1)
-        self.failUnless(remove_loc < removed_message < added_loc)
+        self.assertNotEqual(removed_message, -1)
+        self.assertTrue(remove_loc < removed_message < added_loc)
 
         added_message = out.find('message:\n  foo')
-        self.failIfEqual(added_message, -1)
-        self.failUnless(added_loc < added_message)
+        self.assertNotEqual(added_message, -1)
+        self.assertTrue(added_loc < added_message)
 
     def test_locations(self):
         """Using and remembering different locations"""

=== modified file 'bzrlib/tests/blackbox/test_update.py'
--- bzrlib/tests/blackbox/test_update.py	2010-10-11 02:21:33 +0000
+++ bzrlib/tests/blackbox/test_update.py	2011-07-14 21:01:48 +0000
@@ -90,7 +90,7 @@
 Updated to revision 1 of branch %s
 """ % osutils.pathjoin(self.test_dir, 'branch',),
                          err)
-        self.failUnlessExists('branch/file')
+        self.assertPathExists('branch/file')
 
     def test_update_out_of_date_light_checkout(self):
         self.make_branch_and_tree('branch')
@@ -179,9 +179,9 @@
 """ % osutils.pathjoin(self.test_dir, 'master',),
                          err)
         self.assertEqual([master_tip, child_tip], wt.get_parent_ids())
-        self.failUnlessExists('checkout/file')
-        self.failUnlessExists('checkout/file_b')
-        self.failUnlessExists('checkout/file_c')
+        self.assertPathExists('checkout/file')
+        self.assertPathExists('checkout/file_b')
+        self.assertPathExists('checkout/file_c')
         self.assertTrue(wt.has_filename('file_c'))
 
     def test_update_with_merges(self):
@@ -299,8 +299,8 @@
 2>All changes applied successfully.
 2>Updated to revision 1 of .../master
 ''')
-        self.failUnlessExists('./file1')
-        self.failIfExists('./file2')
+        self.assertPathExists('./file1')
+        self.assertPathDoesNotExist('./file2')
         self.assertEquals(['m1'], master.get_parent_ids())
 
     def test_update_dash_r_outside_history(self):

=== modified file 'bzrlib/tests/blackbox/test_version.py'
--- bzrlib/tests/blackbox/test_version.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/blackbox/test_version.py	2011-07-14 21:01:48 +0000
@@ -108,12 +108,12 @@
         bzr_log = 'my.bzr.log'
         self.overrideEnv('BZR_LOG', bzr_log)
         default_log = os.path.join(os.environ['BZR_HOME'], '.bzr.log')
-        self.failIfExists([default_log, bzr_log])
+        self.assertPathDoesNotExist([default_log, bzr_log])
         out = self.run_bzr_subprocess('version')[0]
         self.assertTrue(len(out) > 0)
         self.assertContainsRe(out, r"(?m)^  Bazaar log file: " + bzr_log)
-        self.failIfExists(default_log)
-        self.failUnlessExists(bzr_log)
+        self.assertPathDoesNotExist(default_log)
+        self.assertPathExists(bzr_log)
 
     def test_dev_null(self):
         # This test uses a subprocess to cause the log opening logic to
@@ -124,8 +124,8 @@
             bzr_log = '/dev/null'
         self.overrideEnv('BZR_LOG', bzr_log)
         default_log = os.path.join(os.environ['BZR_HOME'], '.bzr.log')
-        self.failIfExists(default_log)
+        self.assertPathDoesNotExist(default_log)
         out = self.run_bzr_subprocess('version')[0]
         self.assertTrue(len(out) > 0)
         self.assertContainsRe(out, r"(?m)^  Bazaar log file: " + bzr_log)
-        self.failIfExists(default_log)
+        self.assertPathDoesNotExist(default_log)

=== modified file 'bzrlib/tests/blackbox/test_versioning.py'
--- bzrlib/tests/blackbox/test_versioning.py	2010-09-20 11:30:28 +0000
+++ bzrlib/tests/blackbox/test_versioning.py	2011-07-14 21:01:48 +0000
@@ -39,7 +39,7 @@
         # here locally.
         shared_repo = self.make_repository('.')
         self.run_bzr(['mkdir', 'abc'], retcode=3)
-        self.failIfExists('abc')
+        self.assertPathDoesNotExist('abc')
 
 
 class TestVersioning(TestCaseInTempDir):
@@ -61,7 +61,7 @@
 
         self.assertEquals(len(delta.added), 1)
         self.assertEquals(delta.added[0][0], 'foo')
-        self.failIf(delta.modified)
+        self.assertFalse(delta.modified)
 
     def test_mkdir_in_subdir(self):
         """'bzr mkdir' operation in subdirectory"""
@@ -85,7 +85,7 @@
         self.assertEquals(len(delta.added), 2)
         self.assertEquals(delta.added[0][0], 'dir')
         self.assertEquals(delta.added[1][0], pathjoin('dir','subdir'))
-        self.failIf(delta.modified)
+        self.assertFalse(delta.modified)
 
     def test_mkdir_w_nested_trees(self):
         """'bzr mkdir' with nested trees"""
@@ -100,9 +100,9 @@
         os.chdir('../..')
 
         self.run_bzr(['mkdir', 'dir', 'a/dir', 'a/b/dir'])
-        self.failUnless(os.path.isdir('dir'))
-        self.failUnless(os.path.isdir('a/dir'))
-        self.failUnless(os.path.isdir('a/b/dir'))
+        self.assertTrue(os.path.isdir('dir'))
+        self.assertTrue(os.path.isdir('a/dir'))
+        self.assertTrue(os.path.isdir('a/b/dir'))
 
         wt = WorkingTree.open('.')
         wt_a = WorkingTree.open('a')
@@ -111,17 +111,17 @@
         delta = wt.changes_from(wt.basis_tree())
         self.assertEquals(len(delta.added), 1)
         self.assertEquals(delta.added[0][0], 'dir')
-        self.failIf(delta.modified)
+        self.assertFalse(delta.modified)
 
         delta = wt_a.changes_from(wt_a.basis_tree())
         self.assertEquals(len(delta.added), 1)
         self.assertEquals(delta.added[0][0], 'dir')
-        self.failIf(delta.modified)
+        self.assertFalse(delta.modified)
 
         delta = wt_b.changes_from(wt_b.basis_tree())
         self.assertEquals(len(delta.added), 1)
         self.assertEquals(delta.added[0][0], 'dir')
-        self.failIf(delta.modified)
+        self.assertFalse(delta.modified)
 
     def check_branch(self):
         """After all the above changes, run the check and upgrade commands.

=== modified file 'bzrlib/tests/blackbox/test_whoami.py'
--- bzrlib/tests/blackbox/test_whoami.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/blackbox/test_whoami.py	2011-07-14 21:01:48 +0000
@@ -92,10 +92,13 @@
                           'recommended.\n', display)
 
     def test_whoami_not_set(self):
-        """Ensure whoami error if username is not set.
+        """Ensure whoami error if username is not set and not inferred.
         """
         self.overrideEnv('EMAIL', None)
         self.overrideEnv('BZR_EMAIL', None)
+        # Also, make sure that it's not inferred from mailname.
+        self.overrideAttr(config, '_auto_user_id',
+            lambda: (None, None))
         out, err = self.run_bzr(['whoami'], 3)
         self.assertContainsRe(err, 'Unable to determine your name')
 

=== modified file 'bzrlib/tests/doc_generate/builders/test_texinfo.py'
--- bzrlib/tests/doc_generate/builders/test_texinfo.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/doc_generate/builders/test_texinfo.py	2011-07-14 21:01:48 +0000
@@ -69,5 +69,5 @@
              ])
         app, out, err = self.make_sphinx()
         self.build(app)
-        self.failUnlessExists('index.texi')
-        self.failUnlessExists('content.texi')
+        self.assertPathExists('index.texi')
+        self.assertPathExists('content.texi')

=== modified file 'bzrlib/tests/features.py'
--- bzrlib/tests/features.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/features.py	2011-07-14 21:01:48 +0000
@@ -18,6 +18,7 @@
 
 import os
 import stat
+import sys
 
 from bzrlib import tests
 
@@ -131,3 +132,17 @@
 bash_feature = ExecutableFeature('bash')
 sed_feature = ExecutableFeature('sed')
 diff_feature = ExecutableFeature('diff')
+
+
+class Win32Feature(tests.Feature):
+    """Feature testing whether we're running selftest on Windows
+    or Windows-like platform.
+    """
+
+    def _probe(self):
+        return sys.platform == 'win32'
+
+    def feature_name(self):
+        return "win32 platform"
+
+win32_feature = Win32Feature()

=== modified file 'bzrlib/tests/per_branch/test_bound_sftp.py'
--- bzrlib/tests/per_branch/test_bound_sftp.py	2011-02-03 18:58:06 +0000
+++ bzrlib/tests/per_branch/test_bound_sftp.py	2011-07-14 21:01:48 +0000
@@ -94,8 +94,8 @@
         # this line is more of a working tree test line, but - what the hey,
         # it has work to do.
         b_child.bzrdir.open_workingtree().update()
-        self.failUnlessExists('child/a')
-        self.failUnlessExists('child/b')
+        self.assertPathExists('child/a')
+        self.assertPathExists('child/b')
 
         b_child.unbind()
         self.assertEqual(None, b_child.get_bound_location())
@@ -292,22 +292,22 @@
         wt_other.add('c')
         wt_other.commit('adding c', rev_id='r@d-2')
 
-        self.failIf(wt_child.branch.repository.has_revision('r@d-2'))
-        self.failIf(b_base.repository.has_revision('r@d-2'))
+        self.assertFalse(wt_child.branch.repository.has_revision('r@d-2'))
+        self.assertFalse(b_base.repository.has_revision('r@d-2'))
 
         wt_child.merge_from_branch(wt_other.branch)
 
-        self.failUnlessExists('child/c')
+        self.assertPathExists('child/c')
         self.assertEqual(['r@d-2'], wt_child.get_parent_ids()[1:])
-        self.failUnless(wt_child.branch.repository.has_revision('r@d-2'))
-        self.failIf(b_base.repository.has_revision('r@d-2'))
+        self.assertTrue(wt_child.branch.repository.has_revision('r@d-2'))
+        self.assertFalse(b_base.repository.has_revision('r@d-2'))
 
         # Commit should succeed, and cause merged revisions to
         # be pushed into base
         wt_child.commit('merge other', rev_id='r@c-2')
         self.assertEqual(['r@b-1', 'r@c-2'], wt_child.branch.revision_history())
         self.assertEqual(['r@b-1', 'r@c-2'], b_base.revision_history())
-        self.failUnless(b_base.repository.has_revision('r@d-2'))
+        self.assertTrue(b_base.repository.has_revision('r@d-2'))
 
     def test_commit_fails(self):
         b_base, wt_child = self.create_branches()

=== modified file 'bzrlib/tests/per_branch/test_branch.py'
--- bzrlib/tests/per_branch/test_branch.py	2011-02-03 18:58:06 +0000
+++ bzrlib/tests/per_branch/test_branch.py	2011-07-14 21:01:48 +0000
@@ -360,7 +360,7 @@
         # config file in the branch.
         branch.nick = "Aaron's branch"
         if not isinstance(branch, remote.RemoteBranch):
-            self.failUnless(branch._transport.has("branch.conf"))
+            self.assertTrue(branch._transport.has("branch.conf"))
         # Because the nick has been set explicitly, the nick is now always
         # "Aaron's branch", regardless of directory name.
         self.assertEqual(branch.nick, "Aaron's branch")
@@ -419,7 +419,7 @@
     def test_format_description(self):
         tree = self.make_branch_and_tree('tree')
         text = tree.branch._format.get_format_description()
-        self.failUnless(len(text))
+        self.assertTrue(len(text))
 
     def test_get_commit_builder(self):
         branch = self.make_branch(".")
@@ -685,19 +685,19 @@
         t = self.get_transport()
         readonly_t = transport.get_transport(self.get_readonly_url())
         made_branch = self.make_branch('.')
-        self.failUnless(isinstance(made_branch, _mod_branch.Branch))
+        self.assertIsInstance(made_branch, _mod_branch.Branch)
 
         # find it via bzrdir opening:
         opened_control = bzrdir.BzrDir.open(readonly_t.base)
         direct_opened_branch = opened_control.open_branch()
         self.assertEqual(direct_opened_branch.__class__, made_branch.__class__)
         self.assertEqual(opened_control, direct_opened_branch.bzrdir)
-        self.failUnless(isinstance(direct_opened_branch._format,
-                        self.branch_format.__class__))
+        self.assertIsInstance(direct_opened_branch._format,
+            self.branch_format.__class__)
 
         # find it via Branch.open
         opened_branch = _mod_branch.Branch.open(readonly_t.base)
-        self.failUnless(isinstance(opened_branch, made_branch.__class__))
+        self.assertIsInstance(opened_branch, made_branch.__class__)
         self.assertEqual(made_branch._format.__class__,
                          opened_branch._format.__class__)
         # if it has a unique id string, can we probe for it ?
@@ -746,6 +746,66 @@
         except errors.UpgradeRequired:
             raise tests.TestNotApplicable('Format does not support binding')
 
+    def test_unbind_clears_cached_master_branch(self):
+        """b.unbind clears any cached value of b.get_master_branch."""
+        master = self.make_branch('master')
+        branch = self.make_branch('branch')
+        try:
+            branch.bind(master)
+        except errors.UpgradeRequired:
+            raise tests.TestNotApplicable('Format does not support binding')
+        self.addCleanup(branch.lock_write().unlock)
+        self.assertNotEqual(None, branch.get_master_branch())
+        branch.unbind()
+        self.assertEqual(None, branch.get_master_branch())
+
+    def test_unlocked_does_not_cache_master_branch(self):
+        """Unlocked branches do not cache the result of get_master_branch."""
+        master = self.make_branch('master')
+        branch1 = self.make_branch('branch')
+        try:
+            branch1.bind(master)
+        except errors.UpgradeRequired:
+            raise tests.TestNotApplicable('Format does not support binding')
+        # Open branch1 again
+        branch2 = branch1.bzrdir.open_branch()
+        self.assertNotEqual(None, branch1.get_master_branch())
+        # Unbind the branch via branch2.  branch1 isn't locked so will
+        # immediately return the new value for get_master_branch.
+        branch2.unbind()
+        self.assertEqual(None, branch1.get_master_branch())
+
+    def test_bind_clears_cached_master_branch(self):
+        """b.bind clears any cached value of b.get_master_branch."""
+        master1 = self.make_branch('master1')
+        master2 = self.make_branch('master2')
+        branch = self.make_branch('branch')
+        try:
+            branch.bind(master1)
+        except errors.UpgradeRequired:
+            raise tests.TestNotApplicable('Format does not support binding')
+        self.addCleanup(branch.lock_write().unlock)
+        self.assertNotEqual(None, branch.get_master_branch())
+        branch.bind(master2)
+        self.assertEqual('.', urlutils.relative_url(self.get_url('master2'),
+                branch.get_master_branch().base))
+
+    def test_set_bound_location_clears_cached_master_branch(self):
+        """b.set_bound_location clears any cached value of b.get_master_branch.
+        """
+        master1 = self.make_branch('master1')
+        master2 = self.make_branch('master2')
+        branch = self.make_branch('branch')
+        try:
+            branch.bind(master1)
+        except errors.UpgradeRequired:
+            raise tests.TestNotApplicable('Format does not support binding')
+        self.addCleanup(branch.lock_write().unlock)
+        self.assertNotEqual(None, branch.get_master_branch())
+        branch.set_bound_location(self.get_url('master2'))
+        self.assertEqual('.', urlutils.relative_url(self.get_url('master2'),
+                branch.get_master_branch().base))
+
 
 class TestStrict(per_branch.TestCaseWithBranch):
 

=== modified file 'bzrlib/tests/per_branch/test_create_checkout.py'
--- bzrlib/tests/per_branch/test_create_checkout.py	2010-09-20 11:30:28 +0000
+++ bzrlib/tests/per_branch/test_create_checkout.py	2011-07-14 21:01:48 +0000
@@ -46,8 +46,8 @@
 
         tree2 = tree1.branch.create_checkout('checkout', revision_id='rev-1')
         self.assertEqual('rev-1', tree2.last_revision())
-        self.failUnlessExists('checkout/a')
-        self.failIfExists('checkout/b')
+        self.assertPathExists('checkout/a')
+        self.assertPathDoesNotExist('checkout/b')
 
     def test_create_lightweight_checkout(self):
         """We should be able to make a lightweight checkout."""

=== modified file 'bzrlib/tests/per_branch/test_push.py'
--- bzrlib/tests/per_branch/test_push.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/per_branch/test_push.py	2011-07-14 21:01:48 +0000
@@ -1,4 +1,4 @@
-# Copyright (C) 2007-2010 Canonical Ltd
+# Copyright (C) 2007-2011 Canonical Ltd
 #
 # 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
@@ -114,6 +114,23 @@
         self.assertRaises(errors.BoundBranchConnectionFailure,
                 other.branch.push, checkout.branch)
 
+    def test_push_new_tag_to_bound_branch(self):
+        master = self.make_branch('master')
+        bound = self.make_branch('bound')
+        try:
+            bound.bind(master)
+        except errors.UpgradeRequired:
+            raise tests.TestNotApplicable(
+                'Format does not support bound branches')
+        other = bound.bzrdir.sprout('other').open_branch()
+        try:
+            other.tags.set_tag('new-tag', 'some-rev')
+        except errors.TagsNotSupported:
+            raise tests.TestNotApplicable('Format does not support tags')
+        other.push(bound)
+        self.assertEqual({'new-tag': 'some-rev'}, bound.tags.get_tag_dict())
+        self.assertEqual({'new-tag': 'some-rev'}, master.tags.get_tag_dict())
+
     def test_push_uses_read_lock(self):
         """Push should only need a read lock on the source side."""
         source = self.make_branch_and_tree('source')
@@ -170,6 +187,41 @@
         self.assertEqual(tree.branch.last_revision(),
                          to_branch.last_revision())
 
+    def test_push_repository_no_branch_doesnt_fetch_all_revs(self):
+        # See https://bugs.launchpad.net/bzr/+bug/465517
+        t = self.get_transport('target')
+        t.ensure_base()
+        bzrdir = self.bzrdir_format.initialize_on_transport(t)
+        try:
+            bzrdir.open_branch()
+        except errors.NotBranchError:
+            pass
+        else:
+            raise tests.TestNotApplicable('older formats can\'t have a repo'
+                                          ' without a branch')
+        try:
+            source = self.make_branch_builder('source',
+                                              format=self.bzrdir_format)
+        except errors.UninitializableFormat:
+            raise tests.TestNotApplicable('cannot initialize this format')
+        source.start_series()
+        source.build_snapshot('A', None, [
+            ('add', ('', 'root-id', 'directory', None))])
+        source.build_snapshot('B', ['A'], [])
+        source.build_snapshot('C', ['A'], [])
+        source.finish_series()
+        b = source.get_branch()
+        # Note: We can't read lock the source branch. Some formats take a write
+        # lock to 'set_push_location', which breaks
+        self.addCleanup(b.lock_write().unlock)
+        repo = bzrdir.create_repository()
+        # This means 'push the source branch into this dir'
+        bzrdir.push_branch(b)
+        self.addCleanup(repo.lock_read().unlock)
+        # We should have pushed 'C', but not 'B', since it isn't in the
+        # ancestry
+        self.assertEqual([('A',), ('C',)], sorted(repo.revisions.keys()))
+
     def test_push_overwrite_of_non_tip_with_stop_revision(self):
         """Combining the stop_revision and overwrite options works.
 

=== modified file 'bzrlib/tests/per_branch/test_sprout.py'
--- bzrlib/tests/per_branch/test_sprout.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/per_branch/test_sprout.py	2011-07-14 21:01:48 +0000
@@ -125,7 +125,7 @@
         wt2 = wt.bzrdir.sprout('target',
             revision_id='rev1a').open_workingtree()
         self.assertEqual('rev1a', wt2.last_revision())
-        self.failUnlessExists('target/a')
+        self.assertPathExists('target/a')
 
     def test_sprout_with_unicode_symlink(self):
         # this tests bug #272444

=== modified file 'bzrlib/tests/per_bzrdir/test_bzrdir.py'
--- bzrlib/tests/per_bzrdir/test_bzrdir.py	2010-10-11 02:21:33 +0000
+++ bzrlib/tests/per_bzrdir/test_bzrdir.py	2011-07-14 21:01:48 +0000
@@ -476,10 +476,10 @@
         # must not overwrite existing directories
         self.build_tree(['.bzr.retired.0/', '.bzr.retired.0/junk',],
             transport=transport)
-        self.failUnless(transport.has('.bzr'))
+        self.assertTrue(transport.has('.bzr'))
         bd.retire_bzrdir()
-        self.failIf(transport.has('.bzr'))
-        self.failUnless(transport.has('.bzr.retired.1'))
+        self.assertFalse(transport.has('.bzr'))
+        self.assertTrue(transport.has('.bzr.retired.1'))
 
     def test_retire_bzrdir_limited(self):
         bd = self.make_bzrdir('.')
@@ -487,6 +487,6 @@
         # must not overwrite existing directories
         self.build_tree(['.bzr.retired.0/', '.bzr.retired.0/junk',],
             transport=transport)
-        self.failUnless(transport.has('.bzr'))
+        self.assertTrue(transport.has('.bzr'))
         self.assertRaises((errors.FileExists, errors.DirectoryNotEmpty),
             bd.retire_bzrdir, limit=0)

=== modified file 'bzrlib/tests/per_controldir/test_controldir.py'
--- bzrlib/tests/per_controldir/test_controldir.py	2011-02-03 18:58:06 +0000
+++ bzrlib/tests/per_controldir/test_controldir.py	2011-07-14 21:01:48 +0000
@@ -121,12 +121,12 @@
             bzrdir.destroy_workingtree()
         except errors.UnsupportedOperation:
             raise TestSkipped('Format does not support destroying tree')
-        self.failIfExists('tree/file')
+        self.assertPathDoesNotExist('tree/file')
         self.assertRaises(errors.NoWorkingTree, bzrdir.open_workingtree)
         bzrdir.create_workingtree()
-        self.failUnlessExists('tree/file')
+        self.assertPathExists('tree/file')
         bzrdir.destroy_workingtree_metadata()
-        self.failUnlessExists('tree/file')
+        self.assertPathExists('tree/file')
         self.assertRaises(errors.NoWorkingTree, bzrdir.open_workingtree)
 
     def test_destroy_branch(self):
@@ -762,7 +762,7 @@
                 create_tree_if_local=False)
         except errors.MustHaveWorkingTree:
             raise TestNotApplicable("control dir format requires working tree")
-        self.failIfExists('target/foo')
+        self.assertPathDoesNotExist('target/foo')
         self.assertEqual(tree.branch.last_revision(),
                          target.open_branch().last_revision())
 
@@ -807,7 +807,7 @@
         t = self.get_transport()
         readonly_t = self.get_readonly_transport()
         made_control = self.bzrdir_format.initialize(t.base)
-        self.failUnless(isinstance(made_control, controldir.ControlDir))
+        self.assertIsInstance(made_control, controldir.ControlDir)
         self.assertEqual(self.bzrdir_format,
                          controldir.ControlDirFormat.find_format(readonly_t))
         direct_opened_dir = self.bzrdir_format.open(readonly_t)
@@ -816,7 +816,7 @@
                          opened_dir._format)
         self.assertEqual(direct_opened_dir._format,
                          opened_dir._format)
-        self.failUnless(isinstance(opened_dir, controldir.ControlDir))
+        self.assertIsInstance(opened_dir, controldir.ControlDir)
 
     def test_format_initialize_on_transport_ex(self):
         t = self.get_transport('dir')
@@ -1029,7 +1029,7 @@
         made_control = self.bzrdir_format.initialize(t.base)
         made_repo = made_control.create_repository()
         made_branch = made_control.create_branch()
-        self.failUnless(isinstance(made_branch, bzrlib.branch.Branch))
+        self.assertIsInstance(made_branch, bzrlib.branch.Branch)
         self.assertEqual(made_control, made_branch.bzrdir)
 
     def test_open_branch(self):
@@ -1044,8 +1044,8 @@
         made_branch = made_control.create_branch()
         opened_branch = made_control.open_branch()
         self.assertEqual(made_control, opened_branch.bzrdir)
-        self.failUnless(isinstance(opened_branch, made_branch.__class__))
-        self.failUnless(isinstance(opened_branch._format, made_branch._format.__class__))
+        self.assertIsInstance(opened_branch, made_branch.__class__)
+        self.assertIsInstance(opened_branch._format, made_branch._format.__class__)
 
     def test_list_branches(self):
         if not self.bzrdir_format.is_supported():
@@ -1122,8 +1122,8 @@
         made_repo = made_control.create_repository()
         opened_repo = made_control.open_repository()
         self.assertEqual(made_control, opened_repo.bzrdir)
-        self.failUnless(isinstance(opened_repo, made_repo.__class__))
-        self.failUnless(isinstance(opened_repo._format, made_repo._format.__class__))
+        self.assertIsInstance(opened_repo, made_repo.__class__)
+        self.assertIsInstance(opened_repo._format, made_repo._format.__class__)
 
     def test_create_workingtree(self):
         # a bzrdir can construct a working tree for itself.
@@ -1137,7 +1137,7 @@
         made_repo = made_control.create_repository()
         made_branch = made_control.create_branch()
         made_tree = self.createWorkingTreeOrSkip(made_control)
-        self.failUnless(isinstance(made_tree, workingtree.WorkingTree))
+        self.assertIsInstance(made_tree, workingtree.WorkingTree)
         self.assertEqual(made_control, made_tree.bzrdir)
 
     def test_create_workingtree_revision(self):
@@ -1176,8 +1176,8 @@
                               % (self.bzrdir_format, t))
         opened_tree = made_control.open_workingtree()
         self.assertEqual(made_control, opened_tree.bzrdir)
-        self.failUnless(isinstance(opened_tree, made_tree.__class__))
-        self.failUnless(isinstance(opened_tree._format, made_tree._format.__class__))
+        self.assertIsInstance(opened_tree, made_tree.__class__)
+        self.assertIsInstance(opened_tree._format, made_tree._format.__class__)
 
     def test_get_branch_transport(self):
         dir = self.make_bzrdir('.')
@@ -1379,8 +1379,8 @@
         old_url, new_url = tree.bzrdir.backup_bzrdir()
         old_path = urlutils.local_path_from_url(old_url)
         new_path = urlutils.local_path_from_url(new_url)
-        self.failUnlessExists(old_path)
-        self.failUnlessExists(new_path)
+        self.assertPathExists(old_path)
+        self.assertPathExists(new_path)
         for (((dir_relpath1, _), entries1),
              ((dir_relpath2, _), entries2)) in izip(
                 osutils.walkdirs(old_path),
@@ -1414,7 +1414,7 @@
     def test_format_description(self):
         dir = self.make_bzrdir('.')
         text = dir._format.get_format_description()
-        self.failUnless(len(text))
+        self.assertTrue(len(text))
 
 
 class TestBreakLock(TestCaseWithControlDir):

=== modified file 'bzrlib/tests/per_controldir_colo/test_supported.py'
--- bzrlib/tests/per_controldir_colo/test_supported.py	2011-02-03 18:58:06 +0000
+++ bzrlib/tests/per_controldir_colo/test_supported.py	2011-07-14 21:01:48 +0000
@@ -52,5 +52,5 @@
                 'Control dir does not support creating new branches.')
         made_repo = made_control.create_repository()
         made_branch = made_control.create_branch("colo")
-        self.failUnless(isinstance(made_branch, bzrlib.branch.Branch))
+        self.assertIsInstance(made_branch, bzrlib.branch.Branch)
         self.assertEqual(made_control, made_branch.bzrdir)

=== modified file 'bzrlib/tests/per_repository/test_commit_builder.py'
--- bzrlib/tests/per_repository/test_commit_builder.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/per_repository/test_commit_builder.py	2011-07-14 21:01:48 +0000
@@ -19,6 +19,7 @@
 import os
 
 from bzrlib import (
+    config,
     errors,
     graph,
     inventory,
@@ -1322,6 +1323,10 @@
         # Ensure that when no username is available but a committer is
         # supplied, commit works.
         self.overrideEnv('EMAIL', None)
+        self.overrideEnv('BZR_EMAIL', None)
+        # Also, make sure that it's not inferred from mailname.
+        self.overrideAttr(config, '_auto_user_id',
+            lambda: (None, None))
         tree = self.make_branch_and_tree(".")
         tree.lock_write()
         try:

=== modified file 'bzrlib/tests/per_repository/test_has_same_location.py'
--- bzrlib/tests/per_repository/test_has_same_location.py	2010-09-20 11:30:28 +0000
+++ bzrlib/tests/per_repository/test_has_same_location.py	2011-07-14 21:01:48 +0000
@@ -64,7 +64,7 @@
         """Different repository objects for the same location are the same."""
         repo = self.make_repository('.')
         reopened_repo = repo.bzrdir.open_repository()
-        self.failIf(
+        self.assertFalse(
             repo is reopened_repo,
             "This test depends on reopened_repo being a different instance of "
             "the same repo.")

=== modified file 'bzrlib/tests/per_repository/test_repository.py'
--- bzrlib/tests/per_repository/test_repository.py	2011-02-03 18:58:06 +0000
+++ bzrlib/tests/per_repository/test_repository.py	2011-07-14 21:01:48 +0000
@@ -295,7 +295,7 @@
                               self.repository_format.__class__)
         # find it via Repository.open
         opened_repo = repository.Repository.open(readonly_t.base)
-        self.failUnless(isinstance(opened_repo, made_repo.__class__))
+        self.assertIsInstance(opened_repo, made_repo.__class__)
         self.assertEqual(made_repo._format.__class__,
                          opened_repo._format.__class__)
         # if it has a unique id string, can we probe for it ?
@@ -521,7 +521,7 @@
     def test_format_description(self):
         repo = self.make_repository('.')
         text = repo._format.get_format_description()
-        self.failUnless(len(text))
+        self.assertTrue(len(text))
 
     def test_format_supports_external_lookups(self):
         repo = self.make_repository('.')

=== modified file 'bzrlib/tests/per_transport.py'
--- bzrlib/tests/per_transport.py	2011-02-03 18:58:06 +0000
+++ bzrlib/tests/per_transport.py	2011-07-14 21:01:48 +0000
@@ -285,7 +285,7 @@
             return
 
         t.put_bytes('a', 'some text for a\n')
-        self.failUnless(t.has('a'))
+        self.assertTrue(t.has('a'))
         self.check_transport_contents('some text for a\n', t, 'a')
 
         # The contents should be overwritten
@@ -303,9 +303,9 @@
                     t.put_bytes_non_atomic, 'a', 'some text for a\n')
             return
 
-        self.failIf(t.has('a'))
+        self.assertFalse(t.has('a'))
         t.put_bytes_non_atomic('a', 'some text for a\n')
-        self.failUnless(t.has('a'))
+        self.assertTrue(t.has('a'))
         self.check_transport_contents('some text for a\n', t, 'a')
         # Put also replaces contents
         t.put_bytes_non_atomic('a', 'new\ncontents for\na\n')
@@ -323,7 +323,7 @@
         # Now test the create_parent flag
         self.assertRaises(NoSuchFile, t.put_bytes_non_atomic, 'dir/a',
                                        'contents\n')
-        self.failIf(t.has('dir/a'))
+        self.assertFalse(t.has('dir/a'))
         t.put_bytes_non_atomic('dir/a', 'contents for dir/a\n',
                                create_parent_dir=True)
         self.check_transport_contents('contents for dir/a\n', t, 'dir/a')
@@ -401,7 +401,7 @@
         result = t.put_file('a', StringIO('some text for a\n'))
         # put_file returns the length of the data written
         self.assertEqual(16, result)
-        self.failUnless(t.has('a'))
+        self.assertTrue(t.has('a'))
         self.check_transport_contents('some text for a\n', t, 'a')
         # Put also replaces contents
         result = t.put_file('a', StringIO('new\ncontents for\na\n'))
@@ -419,9 +419,9 @@
                     t.put_file_non_atomic, 'a', StringIO('some text for a\n'))
             return
 
-        self.failIf(t.has('a'))
+        self.assertFalse(t.has('a'))
         t.put_file_non_atomic('a', StringIO('some text for a\n'))
-        self.failUnless(t.has('a'))
+        self.assertTrue(t.has('a'))
         self.check_transport_contents('some text for a\n', t, 'a')
         # Put also replaces contents
         t.put_file_non_atomic('a', StringIO('new\ncontents for\na\n'))
@@ -439,7 +439,7 @@
         # Now test the create_parent flag
         self.assertRaises(NoSuchFile, t.put_file_non_atomic, 'dir/a',
                                        StringIO('contents\n'))
-        self.failIf(t.has('dir/a'))
+        self.assertFalse(t.has('dir/a'))
         t.put_file_non_atomic('dir/a', StringIO('contents for dir/a\n'),
                               create_parent_dir=True)
         self.check_transport_contents('contents for dir/a\n', t, 'dir/a')
@@ -822,9 +822,9 @@
             return
 
         t.put_bytes('a', 'a little bit of text\n')
-        self.failUnless(t.has('a'))
+        self.assertTrue(t.has('a'))
         t.delete('a')
-        self.failIf(t.has('a'))
+        self.assertFalse(t.has('a'))
 
         self.assertRaises(NoSuchFile, t.delete, 'a')
 
@@ -836,9 +836,9 @@
         t.delete_multi(['a', 'c'])
         self.assertEqual([False, True, False],
                 list(t.has_multi(['a', 'b', 'c'])))
-        self.failIf(t.has('a'))
-        self.failUnless(t.has('b'))
-        self.failIf(t.has('c'))
+        self.assertFalse(t.has('a'))
+        self.assertTrue(t.has('b'))
+        self.assertFalse(t.has('c'))
 
         self.assertRaises(NoSuchFile,
                 t.delete_multi, ['a', 'b', 'c'])
@@ -905,7 +905,7 @@
         t.mkdir('foo-baz')
         t.rmdir('foo')
         self.assertRaises((NoSuchFile, PathError), t.rmdir, 'foo')
-        self.failUnless(t.has('foo-bar'))
+        self.assertTrue(t.has('foo-bar'))
 
     def test_rename_dir_succeeds(self):
         t = self.get_transport()
@@ -994,8 +994,8 @@
         self.assertEquals([True, False], list(t.has_multi(['a', 'b'])))
 
         t.move('a', 'b')
-        self.failUnless(t.has('b'))
-        self.failIf(t.has('a'))
+        self.assertTrue(t.has('b'))
+        self.assertFalse(t.has('a'))
 
         self.check_transport_contents('a first file\n', t, 'b')
         self.assertEquals([False, True], list(t.has_multi(['a', 'b'])))
@@ -1003,7 +1003,7 @@
         # Overwrite a file
         t.put_bytes('c', 'c this file\n')
         t.move('c', 'b')
-        self.failIf(t.has('c'))
+        self.assertFalse(t.has('c'))
         self.check_transport_contents('c this file\n', t, 'b')
 
         # TODO: Try to write a test for atomicity
@@ -1063,10 +1063,10 @@
         for path, size in zip(paths, sizes):
             st = t.stat(path)
             if path.endswith('/'):
-                self.failUnless(S_ISDIR(st.st_mode))
+                self.assertTrue(S_ISDIR(st.st_mode))
                 # directory sizes are meaningless
             else:
-                self.failUnless(S_ISREG(st.st_mode))
+                self.assertTrue(S_ISREG(st.st_mode))
                 self.assertEqual(size, st.st_size)
 
         remote_stats = list(t.stat_multi(paths))
@@ -1095,11 +1095,11 @@
         try:
             t.hardlink(source_name, link_name)
 
-            self.failUnless(t.has(source_name))
-            self.failUnless(t.has(link_name))
+            self.assertTrue(t.has(source_name))
+            self.assertTrue(t.has(link_name))
 
             st = t.stat(link_name)
-            self.failUnlessEqual(st[ST_NLINK], 2)
+            self.assertEqual(st[ST_NLINK], 2)
         except TransportNotPossible:
             raise TestSkipped("Transport %s does not support hardlinks." %
                               self._server.__class__)
@@ -1117,11 +1117,11 @@
         try:
             t.symlink(source_name, link_name)
 
-            self.failUnless(t.has(source_name))
-            self.failUnless(t.has(link_name))
+            self.assertTrue(t.has(source_name))
+            self.assertTrue(t.has(link_name))
 
             st = t.stat(link_name)
-            self.failUnless(S_ISLNK(st.st_mode),
+            self.assertTrue(S_ISLNK(st.st_mode),
                 "expected symlink, got mode %o" % st.st_mode)
         except TransportNotPossible:
             raise TestSkipped("Transport %s does not support symlinks." %
@@ -1293,32 +1293,32 @@
 
         self.build_tree(['a', 'b/', 'b/c'], transport=t1)
 
-        self.failUnless(t1.has('a'))
-        self.failUnless(t1.has('b/c'))
-        self.failIf(t1.has('c'))
+        self.assertTrue(t1.has('a'))
+        self.assertTrue(t1.has('b/c'))
+        self.assertFalse(t1.has('c'))
 
         t2 = t1.clone('b')
         self.assertEqual(t1.base + 'b/', t2.base)
 
-        self.failUnless(t2.has('c'))
-        self.failIf(t2.has('a'))
+        self.assertTrue(t2.has('c'))
+        self.assertFalse(t2.has('a'))
 
         t3 = t2.clone('..')
-        self.failUnless(t3.has('a'))
-        self.failIf(t3.has('c'))
+        self.assertTrue(t3.has('a'))
+        self.assertFalse(t3.has('c'))
 
-        self.failIf(t1.has('b/d'))
-        self.failIf(t2.has('d'))
-        self.failIf(t3.has('b/d'))
+        self.assertFalse(t1.has('b/d'))
+        self.assertFalse(t2.has('d'))
+        self.assertFalse(t3.has('b/d'))
 
         if t1.is_readonly():
             self.build_tree_contents([('b/d', 'newfile\n')])
         else:
             t2.put_bytes('d', 'newfile\n')
 
-        self.failUnless(t1.has('b/d'))
-        self.failUnless(t2.has('d'))
-        self.failUnless(t3.has('b/d'))
+        self.assertTrue(t1.has('b/d'))
+        self.assertTrue(t2.has('d'))
+        self.assertTrue(t3.has('b/d'))
 
     def test_clone_to_root(self):
         orig_transport = self.get_transport()
@@ -1410,11 +1410,11 @@
         # smoke test for abspath on win32.
         # a transport based on 'file:///' never fully qualifies the drive.
         transport = _mod_transport.get_transport("file:///")
-        self.failUnlessEqual(transport.abspath("/"), "file:///")
+        self.assertEqual(transport.abspath("/"), "file:///")
 
         # but a transport that starts with a drive spec must keep it.
         transport = _mod_transport.get_transport("file:///C:/")
-        self.failUnlessEqual(transport.abspath("/"), "file:///C:/")
+        self.assertEqual(transport.abspath("/"), "file:///C:/")
 
     def test_local_abspath(self):
         transport = self.get_transport()

=== modified file 'bzrlib/tests/per_tree/test_get_file_mtime.py'
--- bzrlib/tests/per_tree/test_get_file_mtime.py	2010-09-20 11:30:28 +0000
+++ bzrlib/tests/per_tree/test_get_file_mtime.py	2011-07-14 21:01:48 +0000
@@ -38,7 +38,7 @@
         # file, working trees return the on-disk time.
         mtime_file_id = tree.get_file_mtime(file_id='one-id')
         self.assertIsInstance(mtime_file_id, (float, int))
-        self.failUnless(now - 5 < mtime_file_id < now + 5,
+        self.assertTrue(now - 5 < mtime_file_id < now + 5,
                         'now: %f, mtime_file_id: %f' % (now, mtime_file_id ))
         mtime_path = tree.get_file_mtime(file_id='one-id', path='one')
         self.assertEqual(mtime_file_id, mtime_path)

=== modified file 'bzrlib/tests/per_workingtree/test_commit.py'
--- bzrlib/tests/per_workingtree/test_commit.py	2010-09-20 11:30:28 +0000
+++ bzrlib/tests/per_workingtree/test_commit.py	2011-07-14 21:01:48 +0000
@@ -273,7 +273,7 @@
             # older format.
             return
         tree.commit('foo', rev_id='foo', local=True)
-        self.failIf(master.repository.has_revision('foo'))
+        self.assertFalse(master.repository.has_revision('foo'))
         self.assertEqual(_mod_revision.NULL_REVISION,
                          (_mod_revision.ensure_null(master.last_revision())))
 

=== modified file 'bzrlib/tests/per_workingtree/test_executable.py'
--- bzrlib/tests/per_workingtree/test_executable.py	2009-09-10 13:48:15 +0000
+++ bzrlib/tests/per_workingtree/test_executable.py	2011-07-14 21:01:48 +0000
@@ -44,9 +44,9 @@
     def check_exist(self, tree):
         """Just check that both files have the right executable bits set"""
         tree.lock_read()
-        self.failUnless(tree.is_executable(self.a_id),
+        self.assertTrue(tree.is_executable(self.a_id),
                         "'a' lost the execute bit")
-        self.failIf(tree.is_executable(self.b_id),
+        self.assertFalse(tree.is_executable(self.b_id),
                     "'b' gained an execute bit")
         tree.unlock()
 
@@ -61,10 +61,10 @@
             self.assertEqual(
                 [('', tree.inventory.root)],
                 list(tree.inventory.iter_entries()))
-        self.failIf(tree.has_id(self.a_id))
-        self.failIf(tree.has_filename('a'))
-        self.failIf(tree.has_id(self.b_id))
-        self.failIf(tree.has_filename('b'))
+        self.assertFalse(tree.has_id(self.a_id))
+        self.assertFalse(tree.has_filename('a'))
+        self.assertFalse(tree.has_id(self.b_id))
+        self.assertFalse(tree.has_filename('b'))
         tree.unlock()
 
     def commit_and_branch(self):

=== modified file 'bzrlib/tests/per_workingtree/test_move.py'
--- bzrlib/tests/per_workingtree/test_move.py	2010-09-20 11:30:28 +0000
+++ bzrlib/tests/per_workingtree/test_move.py	2011-07-14 21:01:48 +0000
@@ -173,7 +173,7 @@
                                ('b/c', 'c-id')], tree)
         self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id'),
                                ('b/c', 'c-id')], tree.basis_tree())
-        self.failIfExists('a')
+        self.assertPathDoesNotExist('a')
         self.assertFileEqual(a_contents, 'b/a')
         tree._validate()
 
@@ -190,7 +190,7 @@
                                ('c', 'c-id')], tree)
         self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id'),
                                ('b/c', 'c-id')], tree.basis_tree())
-        self.failIfExists('b/c')
+        self.assertPathDoesNotExist('b/c')
         self.assertFileEqual(c_contents, 'c')
         tree._validate()
 
@@ -209,7 +209,7 @@
             self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id'),
                                    ('c', 'c-id')], tree)
         else:
-            self.failUnlessExists('b/c')
+            self.assertPathExists('b/c')
             self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id'),
                                    ('b/c', 'c-id')], tree)
         self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id'),

=== modified file 'bzrlib/tests/per_workingtree/test_pull.py'
--- bzrlib/tests/per_workingtree/test_pull.py	2010-11-05 23:21:04 +0000
+++ bzrlib/tests/per_workingtree/test_pull.py	2011-07-14 21:01:48 +0000
@@ -34,7 +34,7 @@
     def test_pull(self):
         tree_a, tree_b = self.get_pullable_trees()
         tree_b.pull(tree_a.branch)
-        self.failUnless(tree_b.branch.repository.has_revision('A'))
+        self.assertTrue(tree_b.branch.repository.has_revision('A'))
         self.assertEqual(['A'], tree_b.get_parent_ids())
 
     def test_pull_overwrites(self):
@@ -42,8 +42,8 @@
         tree_b.commit('foo', rev_id='B')
         self.assertEqual(['B'], tree_b.branch.revision_history())
         tree_b.pull(tree_a.branch, overwrite=True)
-        self.failUnless(tree_b.branch.repository.has_revision('A'))
-        self.failUnless(tree_b.branch.repository.has_revision('B'))
+        self.assertTrue(tree_b.branch.repository.has_revision('A'))
+        self.assertTrue(tree_b.branch.repository.has_revision('B'))
         self.assertEqual(['A'], tree_b.get_parent_ids())
 
     def test_pull_merges_tree_content(self):
@@ -100,4 +100,4 @@
         work.pull(trunk)
         self.assertLength(0, work.conflicts())
         # The directory removal should succeed
-        self.failIfExists('work/dir')
+        self.assertPathDoesNotExist('work/dir')

=== modified file 'bzrlib/tests/per_workingtree/test_remove.py'
--- bzrlib/tests/per_workingtree/test_remove.py	2010-09-20 11:30:28 +0000
+++ bzrlib/tests/per_workingtree/test_remove.py	2011-07-14 21:01:48 +0000
@@ -29,7 +29,7 @@
     def get_tree(self, files):
         tree = self.make_branch_and_tree('.')
         self.build_tree(files)
-        self.failUnlessExists(files)
+        self.assertPathExists(files)
         return tree
 
     def get_committed_tree(self, files, message="Committing"):
@@ -41,11 +41,11 @@
 
     def assertRemovedAndDeleted(self, files):
         self.assertNotInWorkingTree(files)
-        self.failIfExists(files)
+        self.assertPathDoesNotExist(files)
 
     def assertRemovedAndNotDeleted(self, files):
         self.assertNotInWorkingTree(files)
-        self.failUnlessExists(files)
+        self.assertPathExists(files)
 
     def test_remove_keep(self):
         """Check that files and directories are unversioned but not deleted."""
@@ -79,7 +79,7 @@
         self.assertInWorkingTree(TestRemove.files)
         tree.remove(TestRemove.files, keep_files=False)
         self.assertNotInWorkingTree(TestRemove.files)
-        self.failUnlessExists(TestRemove.backup_files)
+        self.assertPathExists(TestRemove.backup_files)
         tree._validate()
 
     def test_remove_changed_file(self):
@@ -89,7 +89,7 @@
         self.assertInWorkingTree('a')
         tree.remove('a', keep_files=False)
         self.assertNotInWorkingTree(TestRemove.files)
-        self.failUnlessExists('a.~1~')
+        self.assertPathExists('a.~1~')
         tree._validate()
 
     def test_remove_deleted_files(self):
@@ -98,7 +98,7 @@
         for f in TestRemove.rfiles:
             osutils.delete_any(f)
         self.assertInWorkingTree(TestRemove.files)
-        self.failIfExists(TestRemove.files)
+        self.assertPathDoesNotExist(TestRemove.files)
         tree.remove(TestRemove.files, keep_files=False)
         self.assertRemovedAndDeleted(TestRemove.files)
         tree._validate()
@@ -111,7 +111,7 @@
             tree.rename_one(f,f+'x')
         rfilesx = ['bx/cx', 'bx', 'ax', 'dx']
         self.assertInWorkingTree(rfilesx)
-        self.failUnlessExists(rfilesx)
+        self.assertPathExists(rfilesx)
 
         tree.remove(rfilesx, keep_files=False)
         self.assertRemovedAndDeleted(rfilesx)
@@ -127,12 +127,12 @@
         self.build_tree_contents([('ax','changed and renamed!'),
                                   ('bx/cx','changed and renamed!')])
         self.assertInWorkingTree(rfilesx)
-        self.failUnlessExists(rfilesx)
+        self.assertPathExists(rfilesx)
 
         tree.remove(rfilesx, keep_files=False)
         self.assertNotInWorkingTree(rfilesx)
-        self.failUnlessExists(['bx.~1~/cx.~1~', 'bx.~1~', 'ax.~1~'])
-        self.failIfExists('dx.~1~') # unchanged file
+        self.assertPathExists(['bx.~1~/cx.~1~', 'bx.~1~', 'ax.~1~'])
+        self.assertPathDoesNotExist('dx.~1~') # unchanged file
         tree._validate()
 
     def test_force_remove_changed_files(self):
@@ -143,7 +143,7 @@
 
         tree.remove(TestRemove.files, keep_files=False, force=True)
         self.assertRemovedAndDeleted(TestRemove.files)
-        self.failIfExists(['a.~1~', 'b.~1~/', 'b.~1~/c', 'd.~1~/'])
+        self.assertPathDoesNotExist(['a.~1~', 'b.~1~/', 'b.~1~/c', 'd.~1~/'])
         tree._validate()
 
     def test_remove_unknown_files(self):
@@ -151,7 +151,7 @@
         tree = self.get_tree(TestRemove.files)
         tree.remove(TestRemove.files, keep_files=False)
         self.assertRemovedAndDeleted(TestRemove.files)
-        self.failUnlessExists(TestRemove.backup_files)
+        self.assertPathExists(TestRemove.backup_files)
         tree._validate()
 
     def test_remove_nonexisting_files(self):
@@ -206,7 +206,7 @@
 
         tree.remove(files, keep_files=False)
         self.assertNotInWorkingTree(files)
-        self.failUnlessExists('an_ignored_file.~1~')
+        self.assertPathExists('an_ignored_file.~1~')
         tree._validate()
 
     def test_dont_remove_directory_with_unknowns(self):
@@ -216,18 +216,18 @@
 
         self.build_tree(['a/unknown_file'])
         tree.remove('a', keep_files=False)
-        self.failUnlessExists('a.~1~/unknown_file')
+        self.assertPathExists('a.~1~/unknown_file')
 
         self.build_tree(['b/unknown_directory'])
         tree.remove('b', keep_files=False)
-        self.failUnlessExists('b.~1~/unknown_directory')
+        self.assertPathExists('b.~1~/unknown_directory')
 
         self.build_tree(['c/c/unknown_file'])
         tree.remove('c/c', keep_files=False)
-        self.failUnlessExists('c/c.~1~/unknown_file')
+        self.assertPathExists('c/c.~1~/unknown_file')
 
         tree.remove('c', keep_files=False)
-        self.failUnlessExists('c.~1~/')
+        self.assertPathExists('c.~1~/')
 
         self.assertNotInWorkingTree(directories)
         tree._validate()
@@ -242,7 +242,7 @@
         self.build_tree(other_files)
 
         self.assertInWorkingTree(files)
-        self.failUnlessExists(files)
+        self.assertPathExists(files)
 
         tree.remove('b', keep_files=False, force=True)
 
@@ -257,7 +257,7 @@
         self.build_tree_contents([('b/c', "some other new content!")])
 
         tree.remove('b', keep_files=False)
-        self.failUnlessExists('b.~1~/c.~1~')
+        self.assertPathExists('b.~1~/c.~1~')
         self.assertNotInWorkingTree(files)
 
     def test_remove_force_directory_with_changed_file(self):
@@ -281,9 +281,9 @@
         tree.rename_one('somedir/file', 'moved-file')
         tree.remove('somedir', keep_files=False)
         self.assertNotInWorkingTree('somedir')
-        self.failIfExists('somedir')
+        self.assertPathDoesNotExist('somedir')
         self.assertInWorkingTree('moved-file')
-        self.failUnlessExists('moved-file')
+        self.assertPathExists('moved-file')
 
     def test_remove_directory_with_renames(self):
         """Delete directory with renames in or out."""
@@ -298,7 +298,7 @@
         moved_files = ['b/file', 'b/directory/']
         self.assertRemovedAndDeleted(files_to_move)
         self.assertInWorkingTree(moved_files)
-        self.failUnlessExists(moved_files)
+        self.assertPathExists(moved_files)
 
         # check if it works with renames out
         tree.remove('a', keep_files=False)
@@ -315,7 +315,7 @@
         tree.add(['dir', 'dir/file'])
         tree.commit('add file')
         tree.remove('dir/', keep_files=False)
-        self.failIfExists('tree/dir/file')
+        self.assertPathDoesNotExist('tree/dir/file')
         self.assertNotInWorkingTree('tree/dir/file', 'tree')
         tree._validate()
 
@@ -324,15 +324,15 @@
         tree = self.get_committed_tree(['a'])
         tree.remove('a', keep_files=False)
         tree.remove('a', keep_files=False)
-        self.failIfExists('a')
+        self.assertPathDoesNotExist('a')
         tree._validate()
 
     def test_remove_file_and_containing_dir(self):
         tree = self.get_committed_tree(['config/', 'config/file'])
         tree.remove('config/file', keep_files=False)
         tree.remove('config', keep_files=False)
-        self.failIfExists('config/file')
-        self.failIfExists('config')
+        self.assertPathDoesNotExist('config/file')
+        self.assertPathDoesNotExist('config')
         tree._validate()
 
     def test_remove_dir_before_bzr(self):
@@ -340,6 +340,6 @@
         # or the bug doesn't manifest itself.
         tree = self.get_committed_tree(['.aaa/', '.aaa/file'])
         tree.remove('.aaa/', keep_files=False)
-        self.failIfExists('.aaa/file')
-        self.failIfExists('.aaa')
+        self.assertPathDoesNotExist('.aaa/file')
+        self.assertPathDoesNotExist('.aaa')
         tree._validate()

=== modified file 'bzrlib/tests/per_workingtree/test_rename_one.py'
--- bzrlib/tests/per_workingtree/test_rename_one.py	2009-08-26 13:04:49 +0000
+++ bzrlib/tests/per_workingtree/test_rename_one.py	2011-07-14 21:01:48 +0000
@@ -91,7 +91,7 @@
                               tree)
         self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id')],
                               tree.basis_tree())
-        self.failIfExists('a')
+        self.assertPathDoesNotExist('a')
         self.assertFileEqual(a_contents, 'foo')
 
     def test_rename_one_not_localdir(self):
@@ -107,7 +107,7 @@
                               tree)
         self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id')],
                               tree.basis_tree())
-        self.failIfExists('tree/a')
+        self.assertPathDoesNotExist('tree/a')
         self.assertFileEqual(a_contents, 'tree/b/foo')
 
     def test_rename_one_subdir(self):
@@ -126,7 +126,7 @@
                                ('b/d', 'a-id')], tree)
         self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id'),
                                ('b/c', 'c-id')], tree.basis_tree())
-        self.failIfExists('a')
+        self.assertPathDoesNotExist('a')
         self.assertFileEqual(a_contents, 'b/d')
 
     def test_rename_one_parent_dir(self):
@@ -141,7 +141,7 @@
                                ('d', 'c-id')], tree)
         self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id'),
                                ('b/c', 'c-id')], tree.basis_tree())
-        self.failIfExists('b/c')
+        self.assertPathDoesNotExist('b/c')
         self.assertFileEqual(c_contents, 'd')
 
     def test_rename_one_fail_consistent(self):

=== modified file 'bzrlib/tests/per_workingtree/test_workingtree.py'
--- bzrlib/tests/per_workingtree/test_workingtree.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/per_workingtree/test_workingtree.py	2011-07-14 21:01:48 +0000
@@ -204,7 +204,7 @@
         os.unlink('hello.txt')
         tree.remove('hello.txt')
         tree.revert(['hello.txt'])
-        self.failUnlessExists('hello.txt')
+        self.assertPathExists('hello.txt')
 
     def test_versioned_files_not_unknown(self):
         tree = self.make_branch_and_tree('.')
@@ -399,12 +399,12 @@
         wt.set_parent_ids(['B'])
         tree = wt.basis_tree()
         tree.lock_read()
-        self.failUnless(tree.has_filename('bar'))
+        self.assertTrue(tree.has_filename('bar'))
         tree.unlock()
         wt.set_parent_ids(['A'])
         tree = wt.basis_tree()
         tree.lock_read()
-        self.failUnless(tree.has_filename('foo'))
+        self.assertTrue(tree.has_filename('foo'))
         tree.unlock()
 
     def test_clone_tree_revision(self):
@@ -465,7 +465,7 @@
         wt.commit('A', rev_id='A')
         # and update old_tree
         self.assertEqual(0, old_tree.update())
-        self.failUnlessExists('checkout/file')
+        self.assertPathExists('checkout/file')
         self.assertEqual(['A'], old_tree.get_parent_ids())
 
     def test_update_sets_root_id(self):
@@ -486,7 +486,7 @@
         wt.commit('A', rev_id='A')
         # and update checkout
         self.assertEqual(0, checkout.update())
-        self.failUnlessExists('checkout/file')
+        self.assertPathExists('checkout/file')
         self.assertEqual(wt.get_root_id(), checkout.get_root_id())
         self.assertNotEqual(None, wt.get_root_id())
 
@@ -567,10 +567,10 @@
             a.close()
         this.revert()
         self.assertFileEqual('a test\n', 'b1/a')
-        self.failUnlessExists('b1/b.~1~')
-        self.failIfExists('b1/c')
-        self.failIfExists('b1/a.~1~')
-        self.failUnlessExists('b1/d')
+        self.assertPathExists('b1/b.~1~')
+        self.assertPathDoesNotExist('b1/c')
+        self.assertPathDoesNotExist('b1/a.~1~')
+        self.assertPathExists('b1/d')
 
     def test_update_updates_bound_branch_no_local_commits(self):
         # doing an update in a tree updates the branch its bound to too.
@@ -739,7 +739,7 @@
     def test_format_description(self):
         tree = self.make_branch_and_tree('tree')
         text = tree._format.get_format_description()
-        self.failUnless(len(text))
+        self.assertTrue(len(text))
 
     def test_branch_attribute_is_not_settable(self):
         # the branch attribute is an aspect of the working tree, not a
@@ -1063,9 +1063,9 @@
         self.assertEqual(0, wt.update(revision='1'))
         self.assertEqual('1', wt.last_revision())
         self.assertEqual(tip, wt.branch.last_revision())
-        self.failUnlessExists('checkout/file1')
-        self.failIfExists('checkout/file4')
-        self.failIfExists('checkout/file5')
+        self.assertPathExists('checkout/file1')
+        self.assertPathDoesNotExist('checkout/file4')
+        self.assertPathDoesNotExist('checkout/file5')
 
 
 class TestIllegalPaths(TestCaseWithWorkingTree):

=== modified file 'bzrlib/tests/test_atomicfile.py'
--- bzrlib/tests/test_atomicfile.py	2009-04-11 14:25:12 +0000
+++ bzrlib/tests/test_atomicfile.py	2011-07-14 21:01:48 +0000
@@ -33,7 +33,7 @@
 
     def test_commit(self):
         f = atomicfile.AtomicFile('test')
-        self.failIfExists('test')
+        self.assertPathDoesNotExist('test')
         f.write('foo\n')
         f.commit()
 

=== modified file 'bzrlib/tests/test_branch.py'
--- bzrlib/tests/test_branch.py	2011-02-03 18:58:06 +0000
+++ bzrlib/tests/test_branch.py	2011-07-14 21:01:48 +0000
@@ -160,7 +160,7 @@
             dir.create_repository()
             format.initialize(dir)
             found_format = _mod_branch.BranchFormat.find_format(dir)
-            self.failUnless(isinstance(found_format, format.__class__))
+            self.assertIsInstance(found_format, format.__class__)
         check_format(_mod_branch.BzrBranchFormat5(), "bar")
 
     def test_find_format_factory(self):
@@ -260,22 +260,22 @@
 
     def test_layout(self):
         branch = self.make_branch('a', format=self.get_format_name())
-        self.failUnlessExists('a/.bzr/branch/last-revision')
-        self.failIfExists('a/.bzr/branch/revision-history')
-        self.failIfExists('a/.bzr/branch/references')
+        self.assertPathExists('a/.bzr/branch/last-revision')
+        self.assertPathDoesNotExist('a/.bzr/branch/revision-history')
+        self.assertPathDoesNotExist('a/.bzr/branch/references')
 
     def test_config(self):
         """Ensure that all configuration data is stored in the branch"""
         branch = self.make_branch('a', format=self.get_format_name())
         branch.set_parent('http://example.com')
-        self.failIfExists('a/.bzr/branch/parent')
+        self.assertPathDoesNotExist('a/.bzr/branch/parent')
         self.assertEqual('http://example.com', branch.get_parent())
         branch.set_push_location('sftp://example.com')
         config = branch.get_config()._get_branch_data_config()
         self.assertEqual('sftp://example.com',
                          config.get_user_option('push_location'))
         branch.set_bound_location('ftp://example.com')
-        self.failIfExists('a/.bzr/branch/bound')
+        self.assertPathDoesNotExist('a/.bzr/branch/bound')
         self.assertEqual('ftp://example.com', branch.get_bound_location())
 
     def test_set_revision_history(self):
@@ -309,10 +309,10 @@
         subtree.commit('a subtree file')
         subsubtree.commit('a subsubtree file')
         tree.branch.create_checkout('target', lightweight=lightweight)
-        self.failUnlessExists('target')
-        self.failUnlessExists('target/subtree')
-        self.failUnlessExists('target/subtree/file')
-        self.failUnlessExists('target/subtree/subsubtree/file')
+        self.assertPathExists('target')
+        self.assertPathExists('target/subtree')
+        self.assertPathExists('target/subtree/file')
+        self.assertPathExists('target/subtree/subsubtree/file')
         subbranch = _mod_branch.Branch.open('target/subtree/subsubtree')
         if lightweight:
             self.assertEndsWith(subbranch.base, 'source/subtree/subsubtree/')

=== modified file 'bzrlib/tests/test_bundle.py'
--- bzrlib/tests/test_bundle.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_bundle.py	2011-07-14 21:01:48 +0000
@@ -1409,7 +1409,7 @@
         branch = tree_a.branch
         repo_a = branch.repository
         tree_a.commit("base", allow_pointless=True, rev_id='A')
-        self.failIf(branch.repository.has_signature_for_revision_id('A'))
+        self.assertFalse(branch.repository.has_signature_for_revision_id('A'))
         try:
             from bzrlib.testament import Testament
             # monkey patch gpg signing mechanism

=== modified file 'bzrlib/tests/test_bzrdir.py'
--- bzrlib/tests/test_bzrdir.py	2011-02-03 18:58:06 +0000
+++ bzrlib/tests/test_bzrdir.py	2011-07-14 21:01:48 +0000
@@ -70,13 +70,12 @@
 
     def test_get_set_default_format(self):
         old_format = bzrdir.BzrDirFormat.get_default_format()
-        # default is BzrDirFormat6
-        self.failUnless(isinstance(old_format, bzrdir.BzrDirMetaFormat1))
+        self.assertIsInstance(old_format, bzrdir.BzrDirMetaFormat1)
         controldir.ControlDirFormat._set_default_format(SampleBzrDirFormat())
         # creating a bzr dir should now create an instrumented dir.
         try:
             result = bzrdir.BzrDir.create('memory:///')
-            self.failUnless(isinstance(result, SampleBzrDir))
+            self.assertIsInstance(result, SampleBzrDir)
         finally:
             controldir.ControlDirFormat._set_default_format(old_format)
         self.assertEqual(old_format, bzrdir.BzrDirFormat.get_default_format())
@@ -260,7 +259,7 @@
             format.initialize(url)
             t = _mod_transport.get_transport(url)
             found_format = bzrdir.BzrDirFormat.find_format(t)
-            self.failUnless(isinstance(found_format, format.__class__))
+            self.assertIsInstance(found_format, format.__class__)
         check_format(bzrdir.BzrDirFormat5(), "foo")
         check_format(bzrdir.BzrDirFormat6(), "bar")
 
@@ -771,7 +770,7 @@
         tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
         tree2.lock_read()
         self.addCleanup(tree2.unlock)
-        self.failUnlessExists('tree2/subtree/file')
+        self.assertPathExists('tree2/subtree/file')
         self.assertEqual('tree-reference', tree2.kind('subtree-root'))
 
     def test_cloning_metadir(self):
@@ -811,8 +810,8 @@
         # #634470.  -- vila 20100909
         self.assertRaises(errors.NotBranchError,
                           tree.bzrdir.sprout, 'repo/tree2')
-#        self.failUnlessExists('repo/tree2/subtree')
-#        self.failIfExists('repo/tree2/subtree/file')
+#        self.assertPathExists('repo/tree2/subtree')
+#        self.assertPathDoesNotExist('repo/tree2/subtree/file')
 
     def make_foo_bar_baz(self):
         foo = bzrdir.BzrDir.create_branch_convenience('foo').bzrdir

=== modified file 'bzrlib/tests/test_cache_utf8.py'
--- bzrlib/tests/test_cache_utf8.py	2009-04-11 14:25:12 +0000
+++ bzrlib/tests/test_cache_utf8.py	2011-07-14 21:01:48 +0000
@@ -31,37 +31,37 @@
 
     def check_encode(self, rev_id):
         rev_id_utf8 = rev_id.encode('utf-8')
-        self.failIf(rev_id in cache_utf8._unicode_to_utf8_map)
-        self.failIf(rev_id_utf8 in cache_utf8._utf8_to_unicode_map)
+        self.assertFalse(rev_id in cache_utf8._unicode_to_utf8_map)
+        self.assertFalse(rev_id_utf8 in cache_utf8._utf8_to_unicode_map)
 
         # After a single encode, the mapping should exist for
         # both directions
         self.assertEqual(rev_id_utf8, cache_utf8.encode(rev_id))
-        self.failUnless(rev_id in cache_utf8._unicode_to_utf8_map)
-        self.failUnless(rev_id_utf8 in cache_utf8._utf8_to_unicode_map)
+        self.assertTrue(rev_id in cache_utf8._unicode_to_utf8_map)
+        self.assertTrue(rev_id_utf8 in cache_utf8._utf8_to_unicode_map)
 
         self.assertEqual(rev_id, cache_utf8.decode(rev_id_utf8))
 
         cache_utf8.clear_encoding_cache()
-        self.failIf(rev_id in cache_utf8._unicode_to_utf8_map)
-        self.failIf(rev_id_utf8 in cache_utf8._utf8_to_unicode_map)
+        self.assertFalse(rev_id in cache_utf8._unicode_to_utf8_map)
+        self.assertFalse(rev_id_utf8 in cache_utf8._utf8_to_unicode_map)
 
     def check_decode(self, rev_id):
         rev_id_utf8 = rev_id.encode('utf-8')
-        self.failIf(rev_id in cache_utf8._unicode_to_utf8_map)
-        self.failIf(rev_id_utf8 in cache_utf8._utf8_to_unicode_map)
+        self.assertFalse(rev_id in cache_utf8._unicode_to_utf8_map)
+        self.assertFalse(rev_id_utf8 in cache_utf8._utf8_to_unicode_map)
 
         # After a single decode, the mapping should exist for
         # both directions
         self.assertEqual(rev_id, cache_utf8.decode(rev_id_utf8))
-        self.failUnless(rev_id in cache_utf8._unicode_to_utf8_map)
-        self.failUnless(rev_id_utf8 in cache_utf8._utf8_to_unicode_map)
+        self.assertTrue(rev_id in cache_utf8._unicode_to_utf8_map)
+        self.assertTrue(rev_id_utf8 in cache_utf8._utf8_to_unicode_map)
 
         self.assertEqual(rev_id_utf8, cache_utf8.encode(rev_id))
         cache_utf8.clear_encoding_cache()
 
-        self.failIf(rev_id in cache_utf8._unicode_to_utf8_map)
-        self.failIf(rev_id_utf8 in cache_utf8._utf8_to_unicode_map)
+        self.assertFalse(rev_id in cache_utf8._unicode_to_utf8_map)
+        self.assertFalse(rev_id_utf8 in cache_utf8._utf8_to_unicode_map)
 
     def test_ascii(self):
         self.check_decode(u'all_ascii_characters123123123')
@@ -74,7 +74,7 @@
     def test_cached_unicode(self):
         x = u'\xb5yy' + u'\xe5zz'
         y = u'\xb5yy' + u'\xe5zz'
-        self.failIf(x is y)
+        self.assertFalse(x is y)
         xp = cache_utf8.get_cached_unicode(x)
         yp = cache_utf8.get_cached_unicode(y)
 
@@ -84,7 +84,7 @@
     def test_cached_utf8(self):
         x = u'\xb5yy\xe5zz'.encode('utf8')
         y = u'\xb5yy\xe5zz'.encode('utf8')
-        self.failIf(x is y)
+        self.assertFalse(x is y)
         xp = cache_utf8.get_cached_utf8(x)
         yp = cache_utf8.get_cached_utf8(y)
 
@@ -94,7 +94,7 @@
     def test_cached_ascii(self):
         x = '%s %s' % ('simple', 'text')
         y = '%s %s' % ('simple', 'text')
-        self.failIf(x is y)
+        self.assertFalse(x is y)
         xp = cache_utf8.get_cached_ascii(x)
         yp = cache_utf8.get_cached_ascii(y)
 

=== modified file 'bzrlib/tests/test_clean_tree.py'
--- bzrlib/tests/test_clean_tree.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_clean_tree.py	2011-07-14 21:01:48 +0000
@@ -46,12 +46,12 @@
         BzrDir.create_standalone_workingtree('branch')
         os.symlink(os.path.realpath('no-die-please'), 'branch/die-please')
         os.mkdir('no-die-please')
-        self.failUnlessExists('branch/die-please')
+        self.assertPathExists('branch/die-please')
         os.mkdir('no-die-please/child')
 
         clean_tree('branch', unknown=True, no_prompt=True)
-        self.failUnlessExists('no-die-please')
-        self.failUnlessExists('no-die-please/child')
+        self.assertPathExists('no-die-please')
+        self.assertPathExists('no-die-please/child')
 
     def test_iter_deletable(self):
         """Files are selected for deletion appropriately"""

=== modified file 'bzrlib/tests/test_commit.py'
--- bzrlib/tests/test_commit.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_commit.py	2011-07-14 21:01:48 +0000
@@ -381,7 +381,7 @@
         wt = self.make_branch_and_tree('.')
         branch = wt.branch
         wt.commit("base", allow_pointless=True, rev_id='A')
-        self.failIf(branch.repository.has_signature_for_revision_id('A'))
+        self.assertFalse(branch.repository.has_signature_for_revision_id('A'))
         try:
             from bzrlib.testament import Testament
             # monkey patch gpg signing mechanism
@@ -405,7 +405,7 @@
         wt = self.make_branch_and_tree('.')
         branch = wt.branch
         wt.commit("base", allow_pointless=True, rev_id='A')
-        self.failIf(branch.repository.has_signature_for_revision_id('A'))
+        self.assertFalse(branch.repository.has_signature_for_revision_id('A'))
         try:
             from bzrlib.testament import Testament
             # monkey patch gpg signing mechanism
@@ -419,7 +419,7 @@
                               working_tree=wt)
             branch = Branch.open(self.get_url('.'))
             self.assertEqual(branch.revision_history(), ['A'])
-            self.failIf(branch.repository.has_revision('B'))
+            self.assertFalse(branch.repository.has_revision('B'))
         finally:
             bzrlib.gpg.GPGStrategy = oldstrategy
 

=== modified file 'bzrlib/tests/test_config.py'
--- bzrlib/tests/test_config.py	2011-03-13 15:08:21 +0000
+++ bzrlib/tests/test_config.py	2011-07-14 21:01:48 +0000
@@ -41,6 +41,7 @@
     )
 from bzrlib.tests import (
     features,
+    TestSkipped,
     scenarios,
     )
 import configobj
@@ -505,7 +506,7 @@
     def test_cached(self):
         my_config = config.IniBasedConfig.from_string(sample_config_text)
         parser = my_config._get_parser()
-        self.failUnless(my_config._get_parser() is parser)
+        self.assertTrue(my_config._get_parser() is parser)
 
     def _dummy_chown(self, path, uid, gid):
         self.path, self.uid, self.gid = path, uid, gid
@@ -764,7 +765,7 @@
             parser = my_config._get_parser()
         finally:
             config.ConfigObj = oldparserclass
-        self.failUnless(isinstance(parser, InstrumentedConfigObj))
+        self.assertIsInstance(parser, InstrumentedConfigObj)
         self.assertEqual(parser._calls, [('__init__', config.config_filename(),
                                           'utf-8')])
 
@@ -781,7 +782,7 @@
         my_config = config.BranchConfig(branch)
         location_config = my_config._get_location_config()
         self.assertEqual(branch.base, location_config.location)
-        self.failUnless(location_config is my_config._get_location_config())
+        self.assertIs(location_config, my_config._get_location_config())
 
     def test_get_config(self):
         """The Branch.get_config method works properly"""
@@ -1020,7 +1021,7 @@
             parser = my_config._get_parser()
         finally:
             config.ConfigObj = oldparserclass
-        self.failUnless(isinstance(parser, InstrumentedConfigObj))
+        self.assertIsInstance(parser, InstrumentedConfigObj)
         self.assertEqual(parser._calls,
                          [('__init__', config.locations_config_filename(),
                            'utf-8')])
@@ -1028,8 +1029,8 @@
     def test_get_global_config(self):
         my_config = config.BranchConfig(FakeBranch('http://example.com'))
         global_config = my_config._get_global_config()
-        self.failUnless(isinstance(global_config, config.GlobalConfig))
-        self.failUnless(global_config is my_config._get_global_config())
+        self.assertIsInstance(global_config, config.GlobalConfig)
+        self.assertIs(global_config, my_config._get_global_config())
 
     def test__get_matching_sections_no_match(self):
         self.get_branch_config('/')
@@ -2237,3 +2238,25 @@
 # test_user_prompted ?
 class TestAuthenticationRing(tests.TestCaseWithTransport):
     pass
+
+
+class TestAutoUserId(tests.TestCase):
+    """Test inferring an automatic user name."""
+
+    def test_auto_user_id(self):
+        """Automatic inference of user name.
+        
+        This is a bit hard to test in an isolated way, because it depends on
+        system functions that go direct to /etc or perhaps somewhere else.
+        But it's reasonable to say that on Unix, with an /etc/mailname, we ought
+        to be able to choose a user name with no configuration.
+        """
+        if sys.platform == 'win32':
+            raise TestSkipped("User name inference not implemented on win32")
+        realname, address = config._auto_user_id()
+        if os.path.exists('/etc/mailname'):
+            self.assertTrue(realname)
+            self.assertTrue(address)
+        else:
+            self.assertEquals((None, None), (realname, address))
+

=== modified file 'bzrlib/tests/test_conflicts.py'
--- bzrlib/tests/test_conflicts.py	2011-03-13 15:08:21 +0000
+++ bzrlib/tests/test_conflicts.py	2011-07-14 21:01:48 +0000
@@ -473,7 +473,7 @@
         return [('unversion', 'file-id')]
 
     def check_file_doesnt_exist(self):
-        self.failIfExists('branch/file')
+        self.assertPathDoesNotExist('branch/file')
 
     def do_create_file_in_dir(self):
         return [('add', ('dir', 'dir-id', 'directory', '')),
@@ -486,7 +486,7 @@
         self.assertFileEqual('trunk content\nmore content\n', 'branch/dir/file')
 
     def check_file_in_dir_doesnt_exist(self):
-        self.failIfExists('branch/dir/file')
+        self.assertPathDoesNotExist('branch/dir/file')
 
     def _get_resolve_path_arg(self, wt, action):
         return self._path
@@ -567,41 +567,41 @@
         return [('rename', ('file', 'new-file'))]
 
     def check_file_renamed(self):
-        self.failIfExists('branch/file')
-        self.failUnlessExists('branch/new-file')
+        self.assertPathDoesNotExist('branch/file')
+        self.assertPathExists('branch/new-file')
 
     def do_rename_file2(self):
         return [('rename', ('file', 'new-file2'))]
 
     def check_file_renamed2(self):
-        self.failIfExists('branch/file')
-        self.failUnlessExists('branch/new-file2')
+        self.assertPathDoesNotExist('branch/file')
+        self.assertPathExists('branch/new-file2')
 
     def do_rename_dir(self):
         return [('rename', ('dir', 'new-dir'))]
 
     def check_dir_renamed(self):
-        self.failIfExists('branch/dir')
-        self.failUnlessExists('branch/new-dir')
+        self.assertPathDoesNotExist('branch/dir')
+        self.assertPathExists('branch/new-dir')
 
     def do_rename_dir2(self):
         return [('rename', ('dir', 'new-dir2'))]
 
     def check_dir_renamed2(self):
-        self.failIfExists('branch/dir')
-        self.failUnlessExists('branch/new-dir2')
+        self.assertPathDoesNotExist('branch/dir')
+        self.assertPathExists('branch/new-dir2')
 
     def do_delete_file(self):
         return [('unversion', 'file-id')]
 
     def check_file_doesnt_exist(self):
-        self.failIfExists('branch/file')
+        self.assertPathDoesNotExist('branch/file')
 
     def do_delete_dir(self):
         return [('unversion', 'dir-id')]
 
     def check_dir_doesnt_exist(self):
-        self.failIfExists('branch/dir')
+        self.assertPathDoesNotExist('branch/dir')
 
     def do_create_file_in_dir(self):
         return [('add', ('dir', 'dir-id', 'directory', '')),
@@ -611,11 +611,11 @@
         return [('rename', ('dir/file', 'dir/new-file'))]
 
     def check_file_in_dir_renamed(self):
-        self.failIfExists('branch/dir/file')
-        self.failUnlessExists('branch/dir/new-file')
+        self.assertPathDoesNotExist('branch/dir/file')
+        self.assertPathExists('branch/dir/new-file')
 
     def check_file_in_dir_doesnt_exist(self):
-        self.failIfExists('branch/dir/file')
+        self.assertPathDoesNotExist('branch/dir/file')
 
     def _get_resolve_path_arg(self, wt, action):
         tpath = self._this['path']
@@ -912,15 +912,15 @@
         return [('rename', ('dir1', 'dir2/dir1'))]
 
     def check_dir1_moved(self):
-        self.failIfExists('branch/dir1')
-        self.failUnlessExists('branch/dir2/dir1')
+        self.assertPathDoesNotExist('branch/dir1')
+        self.assertPathExists('branch/dir2/dir1')
 
     def do_move_dir2_into_dir1(self):
         return [('rename', ('dir2', 'dir1/dir2'))]
 
     def check_dir2_moved(self):
-        self.failIfExists('branch/dir2')
-        self.failUnlessExists('branch/dir1/dir2')
+        self.assertPathDoesNotExist('branch/dir2')
+        self.assertPathExists('branch/dir1/dir2')
 
     def do_create_dir1_4(self):
         return [('add', ('dir1', 'dir1-id', 'directory', '')),
@@ -932,17 +932,17 @@
         return [('rename', ('dir1', 'dir3/dir4/dir1'))]
 
     def check_dir1_2_moved(self):
-        self.failIfExists('branch/dir1')
-        self.failUnlessExists('branch/dir3/dir4/dir1')
-        self.failUnlessExists('branch/dir3/dir4/dir1/dir2')
+        self.assertPathDoesNotExist('branch/dir1')
+        self.assertPathExists('branch/dir3/dir4/dir1')
+        self.assertPathExists('branch/dir3/dir4/dir1/dir2')
 
     def do_move_dir3_into_dir2(self):
         return [('rename', ('dir3', 'dir1/dir2/dir3'))]
 
     def check_dir3_4_moved(self):
-        self.failIfExists('branch/dir3')
-        self.failUnlessExists('branch/dir1/dir2/dir3')
-        self.failUnlessExists('branch/dir1/dir2/dir3/dir4')
+        self.assertPathDoesNotExist('branch/dir3')
+        self.assertPathExists('branch/dir1/dir2/dir3')
+        self.assertPathExists('branch/dir1/dir2/dir3/dir4')
 
     def _get_resolve_path_arg(self, wt, action):
         # ParentLoop says: moving <conflict_path> into <path>. Cancelled move.
@@ -1051,6 +1051,72 @@
 """)
 
 
+class TestNoFinalPath(script.TestCaseWithTransportAndScript):
+
+    def test_bug_805809(self):
+        self.run_script("""
+$ bzr init trunk
+Created a standalone tree (format: 2a)
+$ cd trunk
+$ echo trunk >file
+$ bzr add
+adding file
+$ bzr commit -m 'create file on trunk'
+2>Committing to: .../trunk/
+2>added file
+2>Committed revision 1.
+# Create a debian branch based on trunk
+$ cd ..
+$ bzr branch trunk -r 1 debian
+2>Branched 1 revision(s).
+$ cd debian
+$ mkdir dir
+$ bzr add
+adding dir
+$ bzr mv file dir
+file => dir/file
+$ bzr commit -m 'rename file to dir/file for debian'
+2>Committing to: .../debian/
+2>added dir
+2>renamed file => dir/file
+2>Committed revision 2.
+# Create an experimental branch with a new root-id
+$ cd ..
+$ bzr init experimental
+Created a standalone tree (format: 2a)
+$ cd experimental
+# merge debian even without a common ancestor
+$ bzr merge ../debian -r0..2
+2>+N  dir/
+2>+N  dir/file
+2>All changes applied successfully.
+$ bzr commit -m 'merging debian into experimental'
+2>Committing to: .../experimental/
+2>deleted 
+2>modified dir
+2>Committed revision 1.
+# Create an ubuntu branch with yet another root-id
+$ cd ..
+$ bzr init ubuntu
+Created a standalone tree (format: 2a)
+$ cd ubuntu
+# Also merge debian
+$ bzr merge ../debian -r0..2
+2>+N  dir/
+2>+N  dir/file
+2>All changes applied successfully.
+$ bzr commit -m 'merging debian'
+2>Committing to: .../ubuntu/
+2>deleted 
+2>modified dir
+2>Committed revision 1.
+# Now try to merge experimental
+$ bzr merge ../experimental
+2>Path conflict: dir / dir
+2>1 conflicts encountered.
+""")
+
+
 class TestResolveActionOption(tests.TestCase):
 
     def setUp(self):

=== modified file 'bzrlib/tests/test_crash.py'
--- bzrlib/tests/test_crash.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_crash.py	2011-07-14 21:01:48 +0000
@@ -15,17 +15,18 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 
+import doctest
+import os
 from StringIO import StringIO
 import sys
 
-
-import os
-
+from testtools.matchers import DocTestMatches
 
 from bzrlib import (
     config,
     crash,
     osutils,
+    plugin,
     tests,
     )
 
@@ -71,3 +72,45 @@
         self.assertContainsRe(report, 'test_apport_report')
         # should also be in there
         self.assertContainsRe(report, '(?m)^CommandLine:')
+
+
+class TestNonApportReporting(tests.TestCase):
+    """Reporting of crash-type bugs without apport.
+    
+    This should work in all environments.
+    """
+
+    def setup_fake_plugins(self):
+        def fake_plugins():
+            fake = plugin.PlugIn('fake_plugin', plugin)
+            fake.version_info = lambda: (1, 2, 3)
+            return {"fake_plugin": fake}
+        self.overrideAttr(plugin, 'plugins', fake_plugins)
+
+    def test_report_bug_legacy(self):
+        self.setup_fake_plugins()
+        err_file = StringIO()
+        try:
+            raise AssertionError("my error")
+        except AssertionError, e:
+            pass
+        crash.report_bug_legacy(sys.exc_info(), err_file)
+        self.assertThat(
+            err_file.getvalue(),
+            DocTestMatches("""\
+bzr: ERROR: exceptions.AssertionError: my error
+
+Traceback (most recent call last):
+  ...
+AssertionError: my error
+
+bzr ... on python ...
+arguments: ...
+plugins: fake_plugin[1.2.3]
+encoding: ...
+
+*** Bazaar has encountered an internal error.  This probably indicates a
+    bug in Bazaar.  You can help us fix it by filing a bug report at
+        https://bugs.launchpad.net/bzr/+filebug
+    including this traceback and a description of the problem.
+""", flags=doctest.ELLIPSIS|doctest.REPORT_UDIFF))

=== modified file 'bzrlib/tests/test_diff.py'
--- bzrlib/tests/test_diff.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_diff.py	2011-07-14 21:01:48 +0000
@@ -226,7 +226,7 @@
         output = StringIO.StringIO()
         diff.internal_diff(u'old_\xb5', ['old_text\n'],
                             u'new_\xe5', ['new_text\n'], output)
-        self.failUnless(isinstance(output.getvalue(), str),
+        self.assertIsInstance(output.getvalue(), str,
             'internal_diff should return bytestrings')
 
 

=== modified file 'bzrlib/tests/test_export.py'
--- bzrlib/tests/test_export.py	2010-09-20 11:30:28 +0000
+++ bzrlib/tests/test_export.py	2011-07-14 21:01:48 +0000
@@ -32,8 +32,8 @@
         wt.add(['a', 'a/b', 'a/c'])
         os.unlink('a/c')
         export.export(wt, 'target', format="dir")
-        self.failUnlessExists('target/a/b')
-        self.failIfExists('target/a/c')
+        self.assertPathExists('target/a/b')
+        self.assertPathDoesNotExist('target/a/c')
 
     def test_dir_export_symlink(self):
         self.requireFeature(tests.SymlinkFeature)
@@ -41,7 +41,7 @@
         os.symlink('source', 'link')
         wt.add(['link'])
         export.export(wt, 'target', format="dir")
-        self.failUnlessExists('target/link')
+        self.assertPathExists('target/link')
 
     def test_dir_export_to_existing_empty_dir_success(self):
         self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
@@ -50,9 +50,9 @@
         wt.commit('1')
         self.build_tree(['target/'])
         export.export(wt, 'target', format="dir")
-        self.failUnlessExists('target/a')
-        self.failUnlessExists('target/b')
-        self.failUnlessExists('target/b/c')
+        self.assertPathExists('target/a')
+        self.assertPathExists('target/b')
+        self.assertPathExists('target/b/c')
 
     def test_dir_export_to_existing_nonempty_dir_fail(self):
         self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
@@ -68,10 +68,10 @@
         wtree.add(['dir2', 'first', 'dir2/second'])
         wtree.commit('1')
         export.export(wtree, 'target1', format='dir', subdir='first')
-        self.failUnlessExists('target1/first')
+        self.assertPathExists('target1/first')
         export.export(wtree, 'target2', format='dir', subdir='dir2/second')
-        self.failUnlessExists('target2/second')
-        
+        self.assertPathExists('target2/second')
+
     def test_dir_export_files_same_timestamp(self):
         builder = self.make_branch_builder('source')
         builder.start_series()

=== modified file 'bzrlib/tests/test_ftp_transport.py'
--- bzrlib/tests/test_ftp_transport.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_ftp_transport.py	2011-07-14 21:01:48 +0000
@@ -44,9 +44,9 @@
 
     def test_aftp_degrade(self):
         t = transport.get_transport('aftp://host/path')
-        self.failUnless(t.is_active)
+        self.assertTrue(t.is_active)
         parent = t.clone('..')
-        self.failUnless(parent.is_active)
+        self.assertTrue(parent.is_active)
 
         self.assertEqual('aftp://host/path', t.abspath(''))
 

=== modified file 'bzrlib/tests/test_generate_ids.py'
--- bzrlib/tests/test_generate_ids.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_generate_ids.py	2011-07-14 21:01:48 +0000
@@ -62,13 +62,13 @@
         # Test both case squashing and length restriction
         fid = gen_file_id('A'*50 + '.txt')
         self.assertStartsWith(fid, 'a'*20 + '-')
-        self.failUnless(len(fid) < 60)
+        self.assertTrue(len(fid) < 60)
 
         # restricting length happens after the other actions, so
         # we preserve as much as possible
         fid = gen_file_id('\xe5\xb5..aBcd\tefGhijKLMnop\tqrstuvwxyz')
         self.assertStartsWith(fid, 'abcdefghijklmnopqrst-')
-        self.failUnless(len(fid) < 60)
+        self.assertTrue(len(fid) < 60)
 
     def test_file_ids_are_ascii(self):
         tail = r'-\d{14}-[a-z0-9]{16}-\d+'

=== modified file 'bzrlib/tests/test_globbing.py'
--- bzrlib/tests/test_globbing.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_globbing.py	2011-07-14 21:01:48 +0000
@@ -37,11 +37,11 @@
                 glob = glob_prefix + glob
             globster = Globster([glob])
             for name in positive:
-                self.failUnless(globster.match(name), repr(
+                self.assertTrue(globster.match(name), repr(
                     u'name "%s" does not match glob "%s" (re=%s)' %
                     (name, glob, globster._regex_patterns[0][0].pattern)))
             for name in negative:
-                self.failIf(globster.match(name), repr(
+                self.assertFalse(globster.match(name), repr(
                     u'name "%s" does match glob "%s" (re=%s)' %
                     (name, glob, globster._regex_patterns[0][0].pattern)))
 

=== modified file 'bzrlib/tests/test_ignores.py'
--- bzrlib/tests/test_ignores.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_ignores.py	2011-07-14 21:01:48 +0000
@@ -76,11 +76,11 @@
     def test_create_if_missing(self):
         # $HOME should be set to '.'
         ignore_path = config.user_ignore_config_filename()
-        self.failIfExists(ignore_path)
+        self.assertPathDoesNotExist(ignore_path)
         user_ignores = ignores.get_user_ignores()
         self.assertEqual(set(ignores.USER_DEFAULTS), user_ignores)
 
-        self.failUnlessExists(ignore_path)
+        self.assertPathExists(ignore_path)
         f = open(ignore_path, 'rb')
         try:
             entries = ignores.parse_ignore_file(f)

=== modified file 'bzrlib/tests/test_inv.py'
--- bzrlib/tests/test_inv.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_inv.py	2011-07-14 21:01:48 +0000
@@ -650,15 +650,15 @@
 
     def test_file_has_text(self):
         file = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
-        self.failUnless(file.has_text())
+        self.assertTrue(file.has_text())
 
     def test_directory_has_text(self):
         dir = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
-        self.failIf(dir.has_text())
+        self.assertFalse(dir.has_text())
 
     def test_link_has_text(self):
         link = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
-        self.failIf(link.has_text())
+        self.assertFalse(link.has_text())
 
     def test_make_entry(self):
         self.assertIsInstance(inventory.make_entry("file", "name", ROOT_ID),
@@ -1219,6 +1219,88 @@
         self.assertEqual(('tree\xce\xa9name', 'tree-root-id', 'tree-rev-id'),
                          inv._bytes_to_utf8name_key(bytes))
 
+    def make_basic_utf8_inventory(self):
+        inv = Inventory()
+        inv.revision_id = "revid"
+        inv.root.revision = "rootrev"
+        root_id = inv.root.file_id
+        inv.add(InventoryFile("fileid", u'f\xefle', root_id))
+        inv["fileid"].revision = "filerev"
+        inv["fileid"].text_sha1 = "ffff"
+        inv["fileid"].text_size = 0
+        inv.add(InventoryDirectory("dirid", u'dir-\N{EURO SIGN}', root_id))
+        inv.add(InventoryFile("childid", u'ch\xefld', "dirid"))
+        inv["childid"].revision = "filerev"
+        inv["childid"].text_sha1 = "ffff"
+        inv["childid"].text_size = 0
+        chk_bytes = self.get_chk_bytes()
+        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
+        bytes = ''.join(chk_inv.to_lines())
+        return CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
+
+    def test__preload_handles_utf8(self):
+        new_inv = self.make_basic_utf8_inventory()
+        self.assertEqual({}, new_inv._fileid_to_entry_cache)
+        self.assertFalse(new_inv._fully_cached)
+        new_inv._preload_cache()
+        self.assertEqual(
+            sorted([new_inv.root_id, "fileid", "dirid", "childid"]),
+            sorted(new_inv._fileid_to_entry_cache.keys()))
+        ie_root = new_inv._fileid_to_entry_cache[new_inv.root_id]
+        self.assertEqual([u'dir-\N{EURO SIGN}', u'f\xefle'],
+                         sorted(ie_root._children.keys()))
+        ie_dir = new_inv._fileid_to_entry_cache['dirid']
+        self.assertEqual([u'ch\xefld'], sorted(ie_dir._children.keys()))
+
+    def test__preload_populates_cache(self):
+        inv = Inventory()
+        inv.revision_id = "revid"
+        inv.root.revision = "rootrev"
+        root_id = inv.root.file_id
+        inv.add(InventoryFile("fileid", "file", root_id))
+        inv["fileid"].revision = "filerev"
+        inv["fileid"].executable = True
+        inv["fileid"].text_sha1 = "ffff"
+        inv["fileid"].text_size = 1
+        inv.add(InventoryDirectory("dirid", "dir", root_id))
+        inv.add(InventoryFile("childid", "child", "dirid"))
+        inv["childid"].revision = "filerev"
+        inv["childid"].executable = False
+        inv["childid"].text_sha1 = "dddd"
+        inv["childid"].text_size = 1
+        chk_bytes = self.get_chk_bytes()
+        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
+        bytes = ''.join(chk_inv.to_lines())
+        new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
+        self.assertEqual({}, new_inv._fileid_to_entry_cache)
+        self.assertFalse(new_inv._fully_cached)
+        new_inv._preload_cache()
+        self.assertEqual(
+            sorted([root_id, "fileid", "dirid", "childid"]),
+            sorted(new_inv._fileid_to_entry_cache.keys()))
+        self.assertTrue(new_inv._fully_cached)
+        ie_root = new_inv._fileid_to_entry_cache[root_id]
+        self.assertEqual(['dir', 'file'], sorted(ie_root._children.keys()))
+        ie_dir = new_inv._fileid_to_entry_cache['dirid']
+        self.assertEqual(['child'], sorted(ie_dir._children.keys()))
+
+    def test__preload_handles_partially_evaluated_inventory(self):
+        new_inv = self.make_basic_utf8_inventory()
+        ie = new_inv[new_inv.root_id]
+        self.assertIs(None, ie._children)
+        self.assertEqual([u'dir-\N{EURO SIGN}', u'f\xefle'],
+                         sorted(ie.children.keys()))
+        # Accessing .children loads _children
+        self.assertEqual([u'dir-\N{EURO SIGN}', u'f\xefle'],
+                         sorted(ie._children.keys()))
+        new_inv._preload_cache()
+        # No change
+        self.assertEqual([u'dir-\N{EURO SIGN}', u'f\xefle'],
+                         sorted(ie._children.keys()))
+        ie_dir = new_inv["dirid"]
+        self.assertEqual([u'ch\xefld'],
+                         sorted(ie_dir._children.keys()))
+
 
 class TestCHKInventoryExpand(tests.TestCaseWithMemoryTransport):
 

=== modified file 'bzrlib/tests/test_lazy_import.py'
--- bzrlib/tests/test_lazy_import.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_lazy_import.py	2011-07-14 21:01:48 +0000
@@ -265,7 +265,7 @@
         InstrumentedReplacer(scope=globals(), name='test_class2',
                              factory=factory)
 
-        self.failIf(test_class2 is TestClass)
+        self.assertFalse(test_class2 is TestClass)
         obj = test_class2()
         self.assertIs(test_class2, TestClass)
         self.assertIsInstance(obj, TestClass)
@@ -298,7 +298,7 @@
         InstrumentedReplacer(scope=globals(), name='test_func1',
                              factory=factory)
 
-        self.failIf(test_func1 is func)
+        self.assertFalse(test_func1 is func)
         val = test_func1(1, 2, c='3')
         self.assertIs(test_func1, func)
 

=== modified file 'bzrlib/tests/test_lazy_regex.py'
--- bzrlib/tests/test_lazy_regex.py	2010-09-20 11:30:28 +0000
+++ bzrlib/tests/test_lazy_regex.py	2011-07-14 21:01:48 +0000
@@ -130,7 +130,7 @@
         lazy_regex.install_lazy_compile()
         lazy_regex.reset_compile()
         pattern = re.compile('foo')
-        self.failIf(isinstance(pattern, lazy_regex.LazyRegex),
+        self.assertFalse(isinstance(pattern, lazy_regex.LazyRegex),
                     'lazy_regex.reset_compile() did not restore the original'
                     ' compile() function %s' % (type(pattern),))
         # but the returned object should still support regex operations

=== modified file 'bzrlib/tests/test_lockdir.py'
--- bzrlib/tests/test_lockdir.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_lockdir.py	2011-07-14 21:01:48 +0000
@@ -628,18 +628,18 @@
         lf1 = LockDir(t, 'test_lock')
 
         lf1.create()
-        self.failUnless(t.has('test_lock'))
+        self.assertTrue(t.has('test_lock'))
 
         t.rmdir('test_lock')
-        self.failIf(t.has('test_lock'))
+        self.assertFalse(t.has('test_lock'))
 
         # This will create 'test_lock' if it needs to
         lf1.lock_write()
-        self.failUnless(t.has('test_lock'))
-        self.failUnless(t.has('test_lock/held/info'))
+        self.assertTrue(t.has('test_lock'))
+        self.assertTrue(t.has('test_lock/held/info'))
 
         lf1.unlock()
-        self.failIf(t.has('test_lock/held/info'))
+        self.assertFalse(t.has('test_lock/held/info'))
 
     def test__format_lock_info(self):
         ld1 = self.get_lock()

=== modified file 'bzrlib/tests/test_lru_cache.py'
--- bzrlib/tests/test_lru_cache.py	2010-09-20 11:30:28 +0000
+++ bzrlib/tests/test_lru_cache.py	2011-07-14 21:01:48 +0000
@@ -38,18 +38,18 @@
     def test_missing(self):
         cache = lru_cache.LRUCache(max_cache=10)
 
-        self.failIf('foo' in cache)
+        self.assertFalse('foo' in cache)
         self.assertRaises(KeyError, cache.__getitem__, 'foo')
 
         cache['foo'] = 'bar'
         self.assertEqual('bar', cache['foo'])
-        self.failUnless('foo' in cache)
-        self.failIf('bar' in cache)
+        self.assertTrue('foo' in cache)
+        self.assertFalse('bar' in cache)
 
     def test_map_None(self):
         # Make sure that we can properly map None as a key.
         cache = lru_cache.LRUCache(max_cache=10)
-        self.failIf(None in cache)
+        self.assertFalse(None in cache)
         cache[None] = 1
         self.assertEqual(1, cache[None])
         cache[None] = 2
@@ -75,8 +75,8 @@
         # With a max cache of 1, adding 'baz' should pop out 'foo'
         cache['baz'] = 'biz'
 
-        self.failIf('foo' in cache)
-        self.failUnless('baz' in cache)
+        self.assertFalse('foo' in cache)
+        self.assertTrue('baz' in cache)
 
         self.assertEqual('biz', cache['baz'])
 
@@ -92,7 +92,7 @@
         # This must kick out 'foo' because it was the last accessed
         cache['nub'] = 'in'
 
-        self.failIf('foo' in cache)
+        self.assertFalse('foo' in cache)
 
     def test_cleanup(self):
         """Test that we can use a cleanup function."""

=== modified file 'bzrlib/tests/test_merge.py'
--- bzrlib/tests/test_merge.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_merge.py	2011-07-14 21:01:48 +0000
@@ -90,8 +90,8 @@
         os.chdir('branch2')
         self.run_bzr('merge ../branch1/baz', retcode=3)
         self.run_bzr('merge ../branch1/foo')
-        self.failUnlessExists('foo')
-        self.failIfExists('bar')
+        self.assertPathExists('foo')
+        self.assertPathDoesNotExist('bar')
         wt2 = WorkingTree.open('.') # opens branch2
         self.assertEqual([tip], wt2.get_parent_ids())
 
@@ -157,12 +157,12 @@
         log = StringIO()
         merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(),
                     this_tree=tree_b, ignore_zero=True)
-        self.failUnless('All changes applied successfully.\n' not in
+        self.assertTrue('All changes applied successfully.\n' not in
             self.get_log())
         tree_b.revert()
         merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(),
                     this_tree=tree_b, ignore_zero=False)
-        self.failUnless('All changes applied successfully.\n' in self.get_log())
+        self.assertTrue('All changes applied successfully.\n' in self.get_log())
 
     def test_merge_inner_conflicts(self):
         tree_a = self.make_branch_and_tree('a')

=== modified file 'bzrlib/tests/test_merge_core.py'
--- bzrlib/tests/test_merge_core.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_merge_core.py	2011-07-14 21:01:48 +0000
@@ -493,16 +493,16 @@
         wtb = d_b.open_workingtree()
         wtb.commit('this revision', allow_pointless=False)
         self.assertEqual(1, wtb.merge_from_branch(wta.branch))
-        self.failUnlessExists('b/file.THIS')
-        self.failUnlessExists('b/file.BASE')
-        self.failUnlessExists('b/file.OTHER')
+        self.assertPathExists('b/file.THIS')
+        self.assertPathExists('b/file.BASE')
+        self.assertPathExists('b/file.OTHER')
         wtb.revert()
         self.assertEqual(1, wtb.merge_from_branch(wta.branch,
                                                   merge_type=WeaveMerger))
-        self.failUnlessExists('b/file')
-        self.failUnlessExists('b/file.THIS')
-        self.failUnlessExists('b/file.BASE')
-        self.failUnlessExists('b/file.OTHER')
+        self.assertPathExists('b/file')
+        self.assertPathExists('b/file.THIS')
+        self.assertPathExists('b/file.BASE')
+        self.assertPathExists('b/file.OTHER')
 
     def test_weave_conflicts_not_in_base(self):
         builder = self.make_branch_builder('source')
@@ -532,11 +532,11 @@
         self.assertEqual(1, tree.merge_from_branch(tree.branch,
                                                    to_revision='D-id',
                                                    merge_type=WeaveMerger))
-        self.failUnlessExists('tree/foo.THIS')
-        self.failUnlessExists('tree/foo.OTHER')
+        self.assertPathExists('tree/foo.THIS')
+        self.assertPathExists('tree/foo.OTHER')
         self.expectFailure('fail to create .BASE in some criss-cross merges',
-            self.failUnlessExists, 'tree/foo.BASE')
-        self.failUnlessExists('tree/foo.BASE')
+            self.assertPathExists, 'tree/foo.BASE')
+        self.assertPathExists('tree/foo.BASE')
 
     def test_merge_unrelated(self):
         """Sucessfully merges unrelated branches with no common names"""
@@ -584,7 +584,7 @@
         wtb.commit('changed file', allow_pointless=False)
         wtb.merge_from_branch(wta.branch, wta.branch.last_revision(),
                               wta.branch.get_rev_id(1))
-        self.failIf(os.path.lexists('b/file'))
+        self.assertFalse(os.path.lexists('b/file'))
 
     def test_merge_metadata_vs_deletion(self):
         """Conflict deletion vs metadata change"""
@@ -618,8 +618,8 @@
         b_wt.commit('r1', rev_id='r1')
         self.assertEqual(0, a_wt.merge_from_branch(b_wt.branch,
             b_wt.branch.last_revision(), b_wt.branch.get_rev_id(1)))
-        self.failUnlessExists('a/un')
-        self.failUnless('a/deux')
+        self.assertPathExists('a/un')
+        self.assertTrue('a/deux')
         self.assertFalse(os.path.exists('a/tmp'))
         self.assertEqual(file('a/un').read(),'DEUX')
         self.assertEqual(file('a/deux').read(),'UN')

=== modified file 'bzrlib/tests/test_multiparent.py'
--- bzrlib/tests/test_multiparent.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_multiparent.py	2011-07-14 21:01:48 +0000
@@ -265,10 +265,10 @@
     def test_filenames(self):
         vf = multiparent.MultiVersionedFile('foop')
         vf.add_version('a\nb\nc\nd'.splitlines(True), 'a', [])
-        self.failUnlessExists('foop.mpknit')
-        self.failIfExists('foop.mpidx')
+        self.assertPathExists('foop.mpknit')
+        self.assertPathDoesNotExist('foop.mpidx')
         vf.save()
-        self.failUnlessExists('foop.mpidx')
+        self.assertPathExists('foop.mpidx')
         vf.destroy()
-        self.failIfExists('foop.mpknit')
-        self.failIfExists('foop.mpidx')
+        self.assertPathDoesNotExist('foop.mpknit')
+        self.assertPathDoesNotExist('foop.mpidx')

=== modified file 'bzrlib/tests/test_osutils.py'
--- bzrlib/tests/test_osutils.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_osutils.py	2011-07-14 21:01:48 +0000
@@ -103,18 +103,18 @@
 class TestContainsWhitespace(tests.TestCase):
 
     def test_contains_whitespace(self):
-        self.failUnless(osutils.contains_whitespace(u' '))
-        self.failUnless(osutils.contains_whitespace(u'hello there'))
-        self.failUnless(osutils.contains_whitespace(u'hellothere\n'))
-        self.failUnless(osutils.contains_whitespace(u'hello\nthere'))
-        self.failUnless(osutils.contains_whitespace(u'hello\rthere'))
-        self.failUnless(osutils.contains_whitespace(u'hello\tthere'))
+        self.assertTrue(osutils.contains_whitespace(u' '))
+        self.assertTrue(osutils.contains_whitespace(u'hello there'))
+        self.assertTrue(osutils.contains_whitespace(u'hellothere\n'))
+        self.assertTrue(osutils.contains_whitespace(u'hello\nthere'))
+        self.assertTrue(osutils.contains_whitespace(u'hello\rthere'))
+        self.assertTrue(osutils.contains_whitespace(u'hello\tthere'))
 
         # \xa0 is "Non-breaking-space" which on some python locales thinks it
         # is whitespace, but we do not.
-        self.failIf(osutils.contains_whitespace(u''))
-        self.failIf(osutils.contains_whitespace(u'hellothere'))
-        self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
+        self.assertFalse(osutils.contains_whitespace(u''))
+        self.assertFalse(osutils.contains_whitespace(u'hellothere'))
+        self.assertFalse(osutils.contains_whitespace(u'hello\xa0there'))
 
 
 class TestRename(tests.TestCaseInTempDir):
@@ -134,8 +134,8 @@
         # This should work everywhere
         self.create_file('a', 'something in a\n')
         self._fancy_rename('a', 'b')
-        self.failIfExists('a')
-        self.failUnlessExists('b')
+        self.assertPathDoesNotExist('a')
+        self.assertPathExists('b')
         self.check_file_contents('b', 'something in a\n')
 
         self.create_file('a', 'new something in a\n')
@@ -148,7 +148,7 @@
         self.create_file('target', 'data in target\n')
         self.assertRaises((IOError, OSError), self._fancy_rename,
                           'missingsource', 'target')
-        self.failUnlessExists('target')
+        self.assertPathExists('target')
         self.check_file_contents('target', 'data in target\n')
 
     def test_fancy_rename_fails_if_source_and_target_missing(self):
@@ -159,8 +159,8 @@
         # Rename should be semi-atomic on all platforms
         self.create_file('a', 'something in a\n')
         osutils.rename('a', 'b')
-        self.failIfExists('a')
-        self.failUnlessExists('b')
+        self.assertPathDoesNotExist('a')
+        self.assertPathExists('b')
         self.check_file_contents('b', 'something in a\n')
 
         self.create_file('a', 'new something in a\n')
@@ -248,8 +248,8 @@
 
         osutils.rmtree('dir')
 
-        self.failIfExists('dir/file')
-        self.failIfExists('dir')
+        self.assertPathDoesNotExist('dir/file')
+        self.assertPathDoesNotExist('dir')
 
 
 class TestDeleteAny(tests.TestCaseInTempDir):
@@ -469,13 +469,13 @@
         f = file('MixedCaseName', 'w')
         f.close()
         actual = osutils.canonical_relpath(self.test_base_dir, 'mixedcasename')
-        self.failUnlessEqual('work/MixedCaseName', actual)
+        self.assertEqual('work/MixedCaseName', actual)
 
     def test_canonical_relpath_missing_tail(self):
         os.mkdir('MixedCaseParent')
         actual = osutils.canonical_relpath(self.test_base_dir,
                                            'mixedcaseparent/nochild')
-        self.failUnlessEqual('work/MixedCaseParent/nochild', actual)
+        self.assertEqual('work/MixedCaseParent/nochild', actual)
 
 
 class Test_CICPCanonicalRelpath(tests.TestCaseWithTransport):
@@ -905,8 +905,8 @@
         b.close()
 
         osutils._win32_rename('b', 'a')
-        self.failUnlessExists('a')
-        self.failIfExists('b')
+        self.assertPathExists('a')
+        self.assertPathDoesNotExist('b')
         self.assertFileEqual('baz\n', 'a')
 
     def test_rename_missing_file(self):
@@ -1595,7 +1595,7 @@
                           ('d', 'source/b', 'target/b'),
                           ('f', 'source/b/c', 'target/b/c'),
                          ], processed_files)
-        self.failIfExists('target')
+        self.assertPathDoesNotExist('target')
         if osutils.has_symlinks():
             self.assertEqual([('source/lnk', 'target/lnk')], processed_links)
 
@@ -1647,7 +1647,7 @@
         old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
         self.assertEqual('foo', old)
         self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
-        self.failIf('BZR_TEST_ENV_VAR' in os.environ)
+        self.assertFalse('BZR_TEST_ENV_VAR' in os.environ)
 
 
 class TestSizeShaFile(tests.TestCaseInTempDir):
@@ -2036,6 +2036,7 @@
         # Whatever the result is, if we don't raise an exception, it's ok.
         osutils.terminal_width()
 
+
 class TestCreationOps(tests.TestCaseInTempDir):
     _test_needs_features = [features.chown_feature]
 
@@ -2071,6 +2072,7 @@
         self.assertEquals(self.uid, s.st_uid)
         self.assertEquals(self.gid, s.st_gid)
 
+
 class TestGetuserUnicode(tests.TestCase):
 
     def test_ascii_user(self):
@@ -2091,6 +2093,13 @@
         self.overrideEnv('LOGNAME', u'jrandom\xb6'.encode(ue))
         self.assertEqual(u'jrandom\xb6', osutils.getuser_unicode())
 
+    def test_no_username_bug_660174(self):
+        self.requireFeature(features.win32_feature)
+        for name in ('LOGNAME', 'USER', 'LNAME', 'USERNAME'):
+            self.overrideEnv(name, None)
+        self.assertEqual(u'UNKNOWN', osutils.getuser_unicode())
+
+
 class TestBackupNames(tests.TestCase):
 
     def setUp(self):

=== modified file 'bzrlib/tests/test_plugins.py'
--- bzrlib/tests/test_plugins.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_plugins.py	2011-07-14 21:01:48 +0000
@@ -91,12 +91,12 @@
                 delattr(plugin, submodule_name)
 
     def assertPluginUnknown(self, name):
-        self.failIf(getattr(bzrlib.plugins, name, None) is not None)
-        self.failIf('bzrlib.plugins.%s' % name in sys.modules)
+        self.assertFalse(getattr(bzrlib.plugins, name, None) is not None)
+        self.assertFalse('bzrlib.plugins.%s' % name in sys.modules)
 
     def assertPluginKnown(self, name):
-        self.failUnless(getattr(bzrlib.plugins, name, None) is not None)
-        self.failUnless('bzrlib.plugins.%s' % name in sys.modules)
+        self.assertTrue(getattr(bzrlib.plugins, name, None) is not None)
+        self.assertTrue('bzrlib.plugins.%s' % name in sys.modules)
 
 
 class TestLoadingPlugins(tests.TestCaseInTempDir, TestPluginMixin):
@@ -109,12 +109,12 @@
         # file name we can use which is also a valid attribute for accessing in
         # activeattributes. - we cannot give import parameters.
         tempattribute = "0"
-        self.failIf(tempattribute in self.activeattributes)
+        self.assertFalse(tempattribute in self.activeattributes)
         # set a place for the plugins to record their loading, and at the same
         # time validate that the location the plugins should record to is
         # valid and correct.
         self.__class__.activeattributes [tempattribute] = []
-        self.failUnless(tempattribute in self.activeattributes)
+        self.assertTrue(tempattribute in self.activeattributes)
         # create two plugin directories
         os.mkdir('first')
         os.mkdir('second')
@@ -147,21 +147,21 @@
         self.assertPluginUnknown('plugin')
 
     def test_plugins_from_different_dirs_can_demand_load(self):
-        self.failIf('bzrlib.plugins.pluginone' in sys.modules)
-        self.failIf('bzrlib.plugins.plugintwo' in sys.modules)
+        self.assertFalse('bzrlib.plugins.pluginone' in sys.modules)
+        self.assertFalse('bzrlib.plugins.plugintwo' in sys.modules)
         # This test tests that having two plugins in different
         # directories with different names allows them both to be loaded, when
         # we do a direct import statement.
         # Determine a file name we can use which is also a valid attribute
         # for accessing in activeattributes. - we cannot give import parameters.
         tempattribute = "different-dirs"
-        self.failIf(tempattribute in self.activeattributes)
+        self.assertFalse(tempattribute in self.activeattributes)
         # set a place for the plugins to record their loading, and at the same
         # time validate that the location the plugins should record to is
         # valid and correct.
         bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
             [tempattribute] = []
-        self.failUnless(tempattribute in self.activeattributes)
+        self.assertTrue(tempattribute in self.activeattributes)
         # create two plugin directories
         os.mkdir('first')
         os.mkdir('second')
@@ -186,8 +186,8 @@
 
         oldpath = bzrlib.plugins.__path__
         try:
-            self.failIf('bzrlib.plugins.pluginone' in sys.modules)
-            self.failIf('bzrlib.plugins.plugintwo' in sys.modules)
+            self.assertFalse('bzrlib.plugins.pluginone' in sys.modules)
+            self.assertFalse('bzrlib.plugins.plugintwo' in sys.modules)
             bzrlib.plugins.__path__ = ['first', 'second']
             exec "import bzrlib.plugins.pluginone"
             self.assertEqual(['first'], self.activeattributes[tempattribute])
@@ -208,13 +208,13 @@
         # check the plugin is not loaded already
         self.assertPluginUnknown('ts_plugin')
         tempattribute = "trailing-slash"
-        self.failIf(tempattribute in self.activeattributes)
+        self.assertFalse(tempattribute in self.activeattributes)
         # set a place for the plugin to record its loading, and at the same
         # time validate that the location the plugin should record to is
         # valid and correct.
         bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
             [tempattribute] = []
-        self.failUnless(tempattribute in self.activeattributes)
+        self.assertTrue(tempattribute in self.activeattributes)
         # create a directory for the plugin
         os.mkdir('plugin_test')
         # write a plugin that will record when its loaded in the

=== modified file 'bzrlib/tests/test_registry.py'
--- bzrlib/tests/test_registry.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_registry.py	2011-07-14 21:01:48 +0000
@@ -39,7 +39,7 @@
         a_registry = registry.Registry()
         self.register_stuff(a_registry)
 
-        self.failUnless(a_registry.default_key is None)
+        self.assertTrue(a_registry.default_key is None)
 
         # test get() (self.default_key is None)
         self.assertRaises(KeyError, a_registry.get)
@@ -49,7 +49,7 @@
 
         # test _set_default_key
         a_registry.default_key = 'five'
-        self.failUnless(a_registry.default_key == 'five')
+        self.assertTrue(a_registry.default_key == 'five')
         self.assertEqual(5, a_registry.get())
         self.assertEqual(5, a_registry.get(None))
         # If they ask for a specific entry, they should get KeyError
@@ -64,9 +64,9 @@
         a_registry = registry.Registry()
         self.register_stuff(a_registry)
 
-        self.failUnless('one' in a_registry)
+        self.assertTrue('one' in a_registry)
         a_registry.remove('one')
-        self.failIf('one' in a_registry)
+        self.assertFalse('one' in a_registry)
         self.assertRaises(KeyError, a_registry.get, 'one')
 
         a_registry.register('one', 'one')
@@ -304,7 +304,7 @@
         self.assertEqual(['function', 'klass', 'module', 'obj'],
                          sorted(a_registry.keys()))
         # The plugin should not be loaded until we grab the first object
-        self.failIf(plugin_name in sys.modules)
+        self.assertFalse(plugin_name in sys.modules)
 
         # By default the plugin won't be in the search path
         self.assertRaises(ImportError, a_registry.get, 'obj')
@@ -314,7 +314,7 @@
         try:
             obj = a_registry.get('obj')
             self.assertEqual('foo', obj)
-            self.failUnless(plugin_name in sys.modules)
+            self.assertTrue(plugin_name in sys.modules)
 
             # Now grab another object
             func = a_registry.get('function')

=== modified file 'bzrlib/tests/test_remote.py'
--- bzrlib/tests/test_remote.py	2011-03-13 15:08:21 +0000
+++ bzrlib/tests/test_remote.py	2011-07-14 21:01:48 +0000
@@ -3216,3 +3216,23 @@
         self.hpss_calls = []
         remote_branch.copy_content_into(local)
         self.assertFalse('Branch.revision_history' in self.hpss_calls)
+
+
+class TestUpdateBoundBranch(tests.TestCaseWithTransport):
+
+    def test_bug_786980(self):
+        self.transport_server = test_server.SmartTCPServer_for_testing
+        wt = self.make_branch_and_tree('master')
+        checkout = wt.branch.create_checkout('checkout')
+        wt.commit('add stuff')
+        last_revid = wt.commit('even more stuff')
+        bound_location = checkout.branch.get_bound_location()
+        # For unclear reasons some users have a bound_location without a final
+        # '/', simulate that by forcing such a value
+        self.assertEndsWith(bound_location, '/')
+        new_location = bound_location.rstrip('/')
+        checkout.branch.set_bound_location(new_location)
+        # bug 786980 was raising ReadOnlyError: A write attempt was made in a
+        # read only transaction during the update()
+        checkout.update()
+        self.assertEquals(last_revid, checkout.last_revision())

=== modified file 'bzrlib/tests/test_repository.py'
--- bzrlib/tests/test_repository.py	2011-03-13 15:08:21 +0000
+++ bzrlib/tests/test_repository.py	2011-07-14 21:01:48 +0000
@@ -128,7 +128,7 @@
             format.initialize(dir)
             t = transport.get_transport(url)
             found_format = repository.RepositoryFormat.find_format(dir)
-            self.failUnless(isinstance(found_format, format.__class__))
+            self.assertIsInstance(found_format, format.__class__)
         check_format(weaverepo.RepositoryFormat7(), "bar")
 
     def test_find_format_no_repository(self):

=== modified file 'bzrlib/tests/test_revert.py'
--- bzrlib/tests/test_revert.py	2010-01-25 19:53:02 +0000
+++ bzrlib/tests/test_revert.py	2011-07-14 21:01:48 +0000
@@ -34,11 +34,11 @@
         self.addCleanup(target_tree.unlock)
         merge.merge_inner(target_tree.branch, source_tree.basis_tree(),
                           target_tree.basis_tree(), this_tree=target_tree)
-        self.failUnlessExists('target/dir')
-        self.failUnlessExists('target/dir/contents')
+        self.assertPathExists('target/dir')
+        self.assertPathExists('target/dir/contents')
         target_tree.revert()
-        self.failIfExists('target/dir/contents')
-        self.failIfExists('target/dir')
+        self.assertPathDoesNotExist('target/dir/contents')
+        self.assertPathDoesNotExist('target/dir')
 
     def test_revert_new(self):
         """Only locally-changed new files should be preserved when reverting
@@ -60,26 +60,26 @@
         tree.add('new_file')
         basis_tree = tree.branch.repository.revision_tree(tree.last_revision())
         tree.revert()
-        self.failUnlessExists('tree/new_file')
+        self.assertPathExists('tree/new_file')
 
         # unchanged files should be deleted
         tree.add('new_file')
         tree.commit('add new_file')
         tree.revert(old_tree=basis_tree)
-        self.failIfExists('tree/new_file')
+        self.assertPathDoesNotExist('tree/new_file')
 
         # files should be deleted if their changes came from merges
         merge_target.merge_from_branch(tree.branch)
-        self.failUnlessExists('merge_target/new_file')
+        self.assertPathExists('merge_target/new_file')
         merge_target.revert()
-        self.failIfExists('merge_target/new_file')
+        self.assertPathDoesNotExist('merge_target/new_file')
 
         # files should not be deleted if changed after a merge
         merge_target.merge_from_branch(tree.branch)
-        self.failUnlessExists('merge_target/new_file')
+        self.assertPathExists('merge_target/new_file')
         self.build_tree_contents([('merge_target/new_file', 'new_contents')])
         merge_target.revert()
-        self.failUnlessExists('merge_target/new_file')
+        self.assertPathExists('merge_target/new_file')
 
     def tree_with_executable(self):
         tree = self.make_branch_and_tree('tree')
@@ -127,11 +127,11 @@
         tree.commit('added file', rev_id='rev1')
         os.unlink('file')
         tree.commit('removed file')
-        self.failIfExists('file')
+        self.assertPathDoesNotExist('file')
         tree.revert(old_tree=tree.branch.repository.revision_tree('rev1'))
-        self.failUnlessExists('file')
+        self.assertPathExists('file')
         tree.revert()
-        self.failIfExists('file')
+        self.assertPathDoesNotExist('file')
         self.assertEqual({}, tree.merge_modified())
 
     def test_empty_deprecated(self):
@@ -154,8 +154,8 @@
         os.rmdir('dir')
         tree.remove(['dir/', 'dir/file1', 'dir/file2'])
         tree.revert(['dir/file1'])
-        self.failUnlessExists('dir/file1')
-        self.failIfExists('dir/file2')
+        self.assertPathExists('dir/file1')
+        self.assertPathDoesNotExist('dir/file2')
         self.assertEqual('dir-id', tree.path2id('dir'))
 
     def test_revert_root_id_change(self):

=== modified file 'bzrlib/tests/test_revisionspec.py'
--- bzrlib/tests/test_revisionspec.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_revisionspec.py	2011-07-14 21:01:48 +0000
@@ -611,7 +611,7 @@
         # XXX: Right now, we use fetch() to make sure the remote revisions
         # have been pulled into the local branch. We may change that
         # behavior in the future.
-        self.failUnless(self.tree.branch.repository.has_revision('new_r3'))
+        self.assertTrue(self.tree.branch.repository.has_revision('new_r3'))
 
     def test_no_commits(self):
         new_tree = self.make_branch_and_tree('new_tree')

=== modified file 'bzrlib/tests/test_script.py'
--- bzrlib/tests/test_script.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_script.py	2011-07-14 21:01:48 +0000
@@ -383,8 +383,8 @@
 $ mkdir ../dir2
 $ cd ..
 """)
-        self.failUnlessExists('dir')
-        self.failUnlessExists('dir2')
+        self.assertPathExists('dir')
+        self.assertPathExists('dir2')
 
 
 class TestCd(script.TestCaseWithTransportAndScript):
@@ -416,7 +416,7 @@
             $ bzr init branch
             Created a standalone tree (format: ...)
             """)
-        self.failUnlessExists('branch')
+        self.assertPathExists('branch')
 
 
 class TestEcho(script.TestCaseWithMemoryTransportAndScript):
@@ -480,39 +480,39 @@
 
     def test_rm_file(self):
         self.run_script('$ echo content >file')
-        self.failUnlessExists('file')
+        self.assertPathExists('file')
         self.run_script('$ rm file')
-        self.failIfExists('file')
+        self.assertPathDoesNotExist('file')
 
     def test_rm_file_force(self):
-        self.failIfExists('file')
+        self.assertPathDoesNotExist('file')
         self.run_script('$ rm -f file')
-        self.failIfExists('file')
+        self.assertPathDoesNotExist('file')
 
     def test_rm_files(self):
         self.run_script("""
 $ echo content >file
 $ echo content >file2
 """)
-        self.failUnlessExists('file2')
+        self.assertPathExists('file2')
         self.run_script('$ rm file file2')
-        self.failIfExists('file2')
+        self.assertPathDoesNotExist('file2')
 
     def test_rm_dir(self):
         self.run_script('$ mkdir dir')
-        self.failUnlessExists('dir')
+        self.assertPathExists('dir')
         self.run_script("""
 $ rm dir
 2>rm: cannot remove 'dir': Is a directory
 """)
-        self.failUnlessExists('dir')
+        self.assertPathExists('dir')
 
     def test_rm_dir_recursive(self):
         self.run_script("""
 $ mkdir dir
 $ rm -r dir
 """)
-        self.failIfExists('dir')
+        self.assertPathDoesNotExist('dir')
 
 
 class TestMv(script.TestCaseWithTransportAndScript):
@@ -524,10 +524,10 @@
 
     def test_move_file(self):
         self.run_script('$ echo content >file')
-        self.failUnlessExists('file')
+        self.assertPathExists('file')
         self.run_script('$ mv file new_name')
-        self.failIfExists('file')
-        self.failUnlessExists('new_name')
+        self.assertPathDoesNotExist('file')
+        self.assertPathExists('new_name')
 
     def test_move_unknown_file(self):
         self.assertRaises(AssertionError,
@@ -539,9 +539,9 @@
 $ echo content >dir/file
 """)
         self.run_script('$ mv dir new_name')
-        self.failIfExists('dir')
-        self.failUnlessExists('new_name')
-        self.failUnlessExists('new_name/file')
+        self.assertPathDoesNotExist('dir')
+        self.assertPathExists('new_name')
+        self.assertPathExists('new_name/file')
 
     def test_move_file_into_dir(self):
         self.run_script("""
@@ -549,9 +549,9 @@
 $ echo content > file
 """)
         self.run_script('$ mv file dir')
-        self.failUnlessExists('dir')
-        self.failIfExists('file')
-        self.failUnlessExists('dir/file')
+        self.assertPathExists('dir')
+        self.assertPathDoesNotExist('file')
+        self.assertPathExists('dir/file')
 
 
 class cmd_test_confirm(commands.Command):

=== modified file 'bzrlib/tests/test_selftest.py'
--- bzrlib/tests/test_selftest.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_selftest.py	2011-07-14 21:01:48 +0000
@@ -107,7 +107,7 @@
 
         filename = u'hell\u00d8'
         self.build_tree_contents([(filename, 'contents of hello')])
-        self.failUnlessExists(filename)
+        self.assertPathExists(filename)
 
 
 class TestClassesAvailable(tests.TestCase):
@@ -512,6 +512,12 @@
         self.assertRaises(AssertionError, self.assertEqualStat,
             os.lstat("foo"), os.lstat("longname"))
 
+    def test_assertPathExists(self):
+        self.assertPathExists('.')
+        self.build_tree(['foo/', 'foo/bar'])
+        self.assertPathExists('foo/bar')
+        self.assertPathDoesNotExist('foo/foo')
+
 
 class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
 
@@ -551,7 +557,7 @@
         tree = self.make_branch_and_memory_tree('dir')
         # Guard against regression into MemoryTransport leaking
         # files to disk instead of keeping them in memory.
-        self.failIf(osutils.lexists('dir'))
+        self.assertFalse(osutils.lexists('dir'))
         self.assertIsInstance(tree, memorytree.MemoryTree)
 
     def test_make_branch_and_memory_tree_with_format(self):
@@ -561,7 +567,7 @@
         tree = self.make_branch_and_memory_tree('dir', format=format)
         # Guard against regression into MemoryTransport leaking
         # files to disk instead of keeping them in memory.
-        self.failIf(osutils.lexists('dir'))
+        self.assertFalse(osutils.lexists('dir'))
         self.assertIsInstance(tree, memorytree.MemoryTree)
         self.assertEqual(format.repository_format.__class__,
             tree.branch.repository._format.__class__)
@@ -571,7 +577,7 @@
         self.assertIsInstance(builder, branchbuilder.BranchBuilder)
         # Guard against regression into MemoryTransport leaking
         # files to disk instead of keeping them in memory.
-        self.failIf(osutils.lexists('dir'))
+        self.assertFalse(osutils.lexists('dir'))
 
     def test_make_branch_builder_with_format(self):
         # Use a repo layout that doesn't conform to a 'named' layout, to ensure
@@ -583,7 +589,7 @@
         the_branch = builder.get_branch()
         # Guard against regression into MemoryTransport leaking
         # files to disk instead of keeping them in memory.
-        self.failIf(osutils.lexists('dir'))
+        self.assertFalse(osutils.lexists('dir'))
         self.assertEqual(format.repository_format.__class__,
                          the_branch.repository._format.__class__)
         self.assertEqual(repo_format.get_format_string(),
@@ -595,7 +601,7 @@
         the_branch = builder.get_branch()
         # Guard against regression into MemoryTransport leaking
         # files to disk instead of keeping them in memory.
-        self.failIf(osutils.lexists('dir'))
+        self.assertFalse(osutils.lexists('dir'))
         dir_format = bzrdir.format_registry.make_bzrdir('knit')
         self.assertEqual(dir_format.repository_format.__class__,
                          the_branch.repository._format.__class__)
@@ -634,8 +640,8 @@
         url2 = self.get_readonly_url('foo/bar')
         t = transport.get_transport(url)
         t2 = transport.get_transport(url2)
-        self.failUnless(isinstance(t, ReadonlyTransportDecorator))
-        self.failUnless(isinstance(t2, ReadonlyTransportDecorator))
+        self.assertIsInstance(t, ReadonlyTransportDecorator)
+        self.assertIsInstance(t2, ReadonlyTransportDecorator)
         self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
 
     def test_get_readonly_url_http(self):
@@ -649,8 +655,8 @@
         # the transport returned may be any HttpTransportBase subclass
         t = transport.get_transport(url)
         t2 = transport.get_transport(url2)
-        self.failUnless(isinstance(t, HttpTransportBase))
-        self.failUnless(isinstance(t2, HttpTransportBase))
+        self.assertIsInstance(t, HttpTransportBase)
+        self.assertIsInstance(t2, HttpTransportBase)
         self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
 
     def test_is_directory(self):
@@ -664,7 +670,7 @@
     def test_make_branch_builder(self):
         builder = self.make_branch_builder('dir')
         rev_id = builder.build_commit()
-        self.failUnlessExists('dir')
+        self.assertPathExists('dir')
         a_dir = bzrdir.BzrDir.open('dir')
         self.assertRaises(errors.NoWorkingTree, a_dir.open_workingtree)
         a_branch = a_dir.open_branch()
@@ -686,7 +692,7 @@
         self.assertIsInstance(result_bzrdir.transport,
                               memory.MemoryTransport)
         # should not be on disk, should only be in memory
-        self.failIfExists('subdir')
+        self.assertPathDoesNotExist('subdir')
 
 
 class TestChrootedTest(tests.ChrootedTestCase):
@@ -2366,7 +2372,7 @@
         # stdout and stderr of the invoked run_bzr
         current_factory = bzrlib.ui.ui_factory
         self.run_bzr(['foo'])
-        self.failIf(current_factory is self.factory)
+        self.assertFalse(current_factory is self.factory)
         self.assertNotEqual(sys.stdout, self.factory.stdout)
         self.assertNotEqual(sys.stderr, self.factory.stderr)
         self.assertEqual('foo\n', self.factory.stdout.getvalue())
@@ -2554,7 +2560,7 @@
         self.assertEqual([], command[2:])
 
     def test_set_env(self):
-        self.failIf('EXISTANT_ENV_VAR' in os.environ)
+        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
         # set in the child
         def check_environment():
             self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
@@ -2566,7 +2572,7 @@
 
     def test_run_bzr_subprocess_env_del(self):
         """run_bzr_subprocess can remove environment variables too."""
-        self.failIf('EXISTANT_ENV_VAR' in os.environ)
+        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
         def check_environment():
             self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
         os.environ['EXISTANT_ENV_VAR'] = 'set variable'
@@ -2578,7 +2584,7 @@
         del os.environ['EXISTANT_ENV_VAR']
 
     def test_env_del_missing(self):
-        self.failIf('NON_EXISTANT_ENV_VAR' in os.environ)
+        self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
         def check_environment():
             self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
         self.check_popen_state = check_environment
@@ -3410,7 +3416,7 @@
 class TestEnvironHandling(tests.TestCase):
 
     def test_overrideEnv_None_called_twice_doesnt_leak(self):
-        self.failIf('MYVAR' in os.environ)
+        self.assertFalse('MYVAR' in os.environ)
         self.overrideEnv('MYVAR', '42')
         # We use an embedded test to make sure we fix the _captureVar bug
         class Test(tests.TestCase):

=== modified file 'bzrlib/tests/test_sftp_transport.py'
--- bzrlib/tests/test_sftp_transport.py	2011-01-21 22:08:19 +0000
+++ bzrlib/tests/test_sftp_transport.py	2011-07-14 21:01:48 +0000
@@ -72,14 +72,14 @@
         t = self.get_transport()
 
         l = t.lock_write('bogus')
-        self.failUnlessExists('bogus.write-lock')
+        self.assertPathExists('bogus.write-lock')
 
         # Don't wait for the lock, locking an already locked
         # file should raise an assert
         self.assertRaises(LockError, t.lock_write, 'bogus')
 
         l.unlock()
-        self.failIf(lexists('bogus.write-lock'))
+        self.assertFalse(lexists('bogus.write-lock'))
 
         open('something.write-lock', 'wb').write('fake lock\n')
         self.assertRaises(LockError, t.lock_write, 'something')
@@ -193,15 +193,15 @@
         # old format branches use a special lock file on sftp.
         b = self.make_branch('', format=bzrdir.BzrDirFormat6())
         b = bzrlib.branch.Branch.open(self.get_url())
-        self.failUnlessExists('.bzr/')
-        self.failUnlessExists('.bzr/branch-format')
-        self.failUnlessExists('.bzr/branch-lock')
+        self.assertPathExists('.bzr/')
+        self.assertPathExists('.bzr/branch-format')
+        self.assertPathExists('.bzr/branch-lock')
 
-        self.failIf(lexists('.bzr/branch-lock.write-lock'))
+        self.assertPathDoesNotExist('.bzr/branch-lock.write-lock')
         b.lock_write()
-        self.failUnlessExists('.bzr/branch-lock.write-lock')
+        self.assertPathExists('.bzr/branch-lock.write-lock')
         b.unlock()
-        self.failIf(lexists('.bzr/branch-lock.write-lock'))
+        self.assertPathDoesNotExist('.bzr/branch-lock.write-lock')
 
     def test_push_support(self):
         self.build_tree(['a/', 'a/foo'])