Merge lp:~jelmer/brz/move-errors-more into lp:brz

[Jelmer Vernooij]

Move more errors out of breezy.errors.

Move more errors out of breezy.errors.

[Martin Packman (gz)]

Okay, couple of notes inline but nothing unexpected on the moves.

review: Approve

=== modified file 'breezy/branch.py'
--- breezy/branch.py	2017-07-15 13:23:08 +0000
+++ breezy/branch.py	2017-07-24 01:10:54 +0000
@@ -59,6 +59,17 @@
 from .trace import mutter, mutter_callsite, note, is_quiet
 
 
+class UnstackableBranchFormat(errors.BzrError):
+
+    _fmt = ("The branch '%(url)s'(%(format)s) is not a stackable format. "
+        "You will need to upgrade the branch to permit branch stacking.")
+
+    def __init__(self, format, url):
+        errors.BzrError.__init__(self)
+        self.format = format
+        self.url = url
+
+
 class Branch(controldir.ControlComponent):
     """Branch holding a history of revisions.
 
@@ -816,7 +827,7 @@
             stacking.
         """
         if not self._format.supports_stacking():
-            raise errors.UnstackableBranchFormat(self._format, self.user_url)
+            raise UnstackableBranchFormat(self._format, self.user_url)
         # XXX: Changing from one fallback repository to another does not check
         # that all the data you need is present in the new fallback.
         # Possibly it should.
@@ -824,7 +835,7 @@
         if not url:
             try:
                 old_url = self.get_stacked_on_url()
-            except (errors.NotStacked, errors.UnstackableBranchFormat,
+            except (errors.NotStacked, UnstackableBranchFormat,
                 errors.UnstackableRepositoryFormat):
                 return
             self._unstack()

=== modified file 'breezy/builtins.py'
--- breezy/builtins.py	2017-07-24 01:07:36 +0000
+++ breezy/builtins.py	2017-07-24 01:10:54 +0000
@@ -60,7 +60,7 @@
 from breezy.bzr import (
     btree_index,
     )
-from breezy.branch import Branch
+from breezy.branch import Branch, UnstackableBranchFormat
 from breezy.conflicts import ConflictList
 from breezy.transport import memory
 from breezy.revisionspec import RevisionSpec, RevisionInfo
@@ -1524,7 +1524,7 @@
         try:
             note(gettext('Created new stacked branch referring to %s.') %
                 branch.get_stacked_on_url())
-        except (errors.NotStacked, errors.UnstackableBranchFormat,
+        except (errors.NotStacked, UnstackableBranchFormat,
             errors.UnstackableRepositoryFormat) as e:
             note(ngettext('Branched %d revision.', 'Branched %d revisions.', branch.revno()) % branch.revno())
         if bind:

=== modified file 'breezy/bzr/_dirstate_helpers_py.py'
--- breezy/bzr/_dirstate_helpers_py.py	2017-06-11 13:48:12 +0000
+++ breezy/bzr/_dirstate_helpers_py.py	2017-07-24 01:10:54 +0000
@@ -24,8 +24,7 @@
 
 # We cannot import the dirstate module, because it loads this module
 # All we really need is the IN_MEMORY_MODIFIED constant
-from breezy import errors
-from .dirstate import DirState
+from .dirstate import DirState, DirstateCorrupt
 from ..sixish import (
     range,
     )
@@ -229,7 +228,7 @@
     # Remove the last blank entry
     trailing = fields.pop()
     if trailing != b'':
-        raise errors.DirstateCorrupt(state,
+        raise DirstateCorrupt(state,
             'trailing garbage: %r' % (trailing,))
     # consider turning fields into a tuple.
 
@@ -248,7 +247,7 @@
     field_count = len(fields)
     # this checks our adjustment, and also catches file too short.
     if field_count - cur != expected_field_count:
-        raise errors.DirstateCorrupt(state,
+        raise DirstateCorrupt(state,
             'field count incorrect %s != %s, entry_size=%s, '\
             'num_entries=%s fields=%r' % (
             field_count - cur, expected_field_count, entry_size,

=== modified file 'breezy/bzr/_dirstate_helpers_pyx.pyx'
--- breezy/bzr/_dirstate_helpers_pyx.pyx	2017-06-10 21:59:15 +0000
+++ breezy/bzr/_dirstate_helpers_pyx.pyx	2017-07-24 01:10:54 +0000
@@ -28,8 +28,8 @@
 import stat
 import sys
 
-from .. import cache_utf8, errors, osutils
-from .dirstate import DirState
+from .. import cache_utf8, osutils
+from .dirstate import DirState, DirstateCorrupt
 from ..osutils import parent_directories, pathjoin, splitpath
 
 
@@ -561,7 +561,7 @@
         self.cur_cstr = <char*>memchr(next, c'\0', self.end_cstr - next)
         if self.cur_cstr == NULL:
             extra_len = self.end_cstr - next
-            raise errors.DirstateCorrupt(self.state,
+            raise DirstateCorrupt(self.state,
                 'failed to find trailing NULL (\\0).'
                 ' Trailing garbage: %r'
                 % safe_string_from_size(next, extra_len))
@@ -720,7 +720,7 @@
         # marker.
         trailing = self.get_next(&cur_size)
         if cur_size != 1 or trailing[0] != c'\n':
-            raise errors.DirstateCorrupt(self.state,
+            raise DirstateCorrupt(self.state,
                 'Bad parse, we expected to end on \\n, not: %d %s: %s'
                 % (cur_size, safe_string_from_size(trailing, cur_size),
                    ret))
@@ -767,7 +767,7 @@
             PyList_Append(current_block, entry)
             entry_count = entry_count + 1
         if entry_count != expected_entry_count:
-            raise errors.DirstateCorrupt(self.state,
+            raise DirstateCorrupt(self.state,
                     'We read the wrong number of entries.'
                     ' We expected to read %s, but read %s'
                     % (expected_entry_count, entry_count))
@@ -1326,7 +1326,7 @@
             parent_entry = self.state._get_entry(self.target_index,
                                                  path_utf8=entry[0][0])
             if parent_entry is None:
-                raise errors.DirstateCorrupt(self.state,
+                raise DirstateCorrupt(self.state,
                     "We could not find the parent entry in index %d"
                     " for the entry: %s"
                     % (self.target_index, entry[0]))

=== modified file 'breezy/bzr/branch.py'
--- breezy/bzr/branch.py	2017-06-14 23:29:06 +0000
+++ breezy/bzr/branch.py	2017-07-24 01:10:54 +0000
@@ -42,6 +42,7 @@
     BranchFormat,
     BranchWriteLockResult,
     format_registry,
+    UnstackableBranchFormat,
     )
 from ..decorators import (
     needs_read_lock,
@@ -260,7 +261,7 @@
         return None
 
     def get_stacked_on_url(self):
-        raise errors.UnstackableBranchFormat(self._format, self.user_url)
+        raise UnstackableBranchFormat(self._format, self.user_url)
 
     def set_push_location(self, location):
         """See Branch.set_push_location."""
@@ -409,7 +410,7 @@
         try:
             url = self.get_stacked_on_url()
         except (errors.UnstackableRepositoryFormat, errors.NotStacked,
-            errors.UnstackableBranchFormat):
+            UnstackableBranchFormat):
             pass
         else:
             for hook in Branch.hooks['transform_fallback_location']:
@@ -650,7 +651,7 @@
     """
 
     def get_stacked_on_url(self):
-        raise errors.UnstackableBranchFormat(self._format, self.user_url)
+        raise UnstackableBranchFormat(self._format, self.user_url)
 
 
 class BranchFormatMetadir(bzrdir.BzrFormat, BranchFormat):

=== modified file 'breezy/bzr/bzrdir.py'
--- breezy/bzr/bzrdir.py	2017-07-21 14:18:24 +0000
+++ breezy/bzr/bzrdir.py	2017-07-24 01:10:54 +0000
@@ -33,6 +33,7 @@
 lazy_import(globals(), """
 import breezy
 from breezy import (
+    branch as _mod_branch,
     cleanup,
     fetch,
     graph,
@@ -85,6 +86,14 @@
         self.feature = feature
 
 
+class FeatureAlreadyRegistered(errors.BzrError):
+
+    _fmt = 'The feature %(feature)s has already been registered.'
+
+    def __init__(self, feature):
+        self.feature = feature
+
+
 class BzrDir(controldir.ControlDir):
     """A .bzr control diretory.
 
@@ -177,7 +186,7 @@
             if preserve_stacking:
                 try:
                     stacked_on = local_branch.get_stacked_on_url()
-                except (errors.UnstackableBranchFormat,
+                except (_mod_branch.UnstackableBranchFormat,
                         errors.UnstackableRepositoryFormat,
                         errors.NotStacked):
                     pass
@@ -1856,7 +1865,7 @@
                 stack_on = self._get_full_stack_on()
         try:
             branch.set_stacked_on_url(stack_on)
-        except (errors.UnstackableBranchFormat,
+        except (_mod_branch.UnstackableBranchFormat,
                 errors.UnstackableRepositoryFormat):
             if self._require_stacking:
                 raise

=== modified file 'breezy/bzr/dirstate.py'
--- breezy/bzr/dirstate.py	2017-06-14 23:29:06 +0000
+++ breezy/bzr/dirstate.py	2017-07-24 01:10:54 +0000
@@ -258,6 +258,16 @@
 ERROR_DIRECTORY = 267
 
 
+class DirstateCorrupt(errors.BzrError):
+
+    _fmt = "The dirstate file (%(state)s) appears to be corrupt: %(msg)s"
+
+    def __init__(self, state, msg):
+        errors.BzrError.__init__(self)
+        self.state = state
+        self.msg = msg
+
+
 class SHA1Provider(object):
     """An interface for getting sha1s of a file."""
 
@@ -3583,7 +3593,7 @@
                 # update the source details variable to be the real
                 # location.
                 if old_entry == (None, None):
-                    raise errors.CorruptDirstate(self.state._filename,
+                    raise DirstateCorrupt(self.state._filename,
                         "entry '%s/%s' is considered renamed from %r"
                         " but source does not exist\n"
                         "entry: %s" % (entry[0][0], entry[0][1], old_path, entry))

=== modified file 'breezy/bzr/groupcompress.py'
--- breezy/bzr/groupcompress.py	2017-06-11 13:48:12 +0000
+++ breezy/bzr/groupcompress.py	2017-07-24 01:10:54 +0000
@@ -27,7 +27,6 @@
     annotate,
     config,
     debug,
-    errors,
     graph as _mod_graph,
     osutils,
     static_tuple,
@@ -42,6 +41,9 @@
 from breezy.i18n import gettext
 """)
 
+from .. import (
+    errors,
+    )
 from .btree_index import BTreeBuilder
 from ..lru_cache import LRUSizeCache
 from ..sixish import (
@@ -92,6 +94,18 @@
     return present_keys
 
 
+class DecompressCorruption(errors.BzrError):
+
+    _fmt = "Corruption while decompressing repository file%(orig_error)s"
+
+    def __init__(self, orig_error=None):
+        if orig_error is not None:
+            self.orig_error = ", %s" % (orig_error,)
+        else:
+            self.orig_error = ""
+        errors.BzrError.__init__(self)
+
+
 # The max zlib window size is 32kB, so if we set 'max_size' output of the
 # decompressor to the requested bytes + 32kB, then we should guarantee
 # num_bytes coming out.
@@ -457,7 +471,7 @@
                 try:
                     self._manager._prepare_for_extract()
                 except zlib.error as value:
-                    raise errors.DecompressCorruption("zlib: " + str(value))
+                    raise DecompressCorruption("zlib: " + str(value))
                 block = self._manager._block
                 self._bytes = block.extract(self.key, self._start, self._end)
                 # There are code paths that first extract as fulltext, and then

=== modified file 'breezy/bzr/index.py'
--- breezy/bzr/index.py	2017-06-11 13:48:12 +0000
+++ breezy/bzr/index.py	2017-07-24 01:10:54 +0000
@@ -28,7 +28,6 @@
 
 from bisect import bisect_right
 import re
-import sys
 
 from ..lazy_import import lazy_import
 lazy_import(globals(), """
@@ -56,6 +55,62 @@
 _SIGNATURE = b"Bazaar Graph Index 1\n"
 
 
+class BadIndexFormatSignature(errors.BzrError):
+
+    _fmt = "%(value)s is not an index of type %(_type)s."
+
+    def __init__(self, value, _type):
+        errors.BzrError.__init__(self)
+        self.value = value
+        self._type = _type
+
+
+class BadIndexData(errors.BzrError):
+
+    _fmt = "Error in data for index %(value)s."
+
+    def __init__(self, value):
+        errors.BzrError.__init__(self)
+        self.value = value
+
+
+class BadIndexDuplicateKey(errors.BzrError):
+
+    _fmt = "The key '%(key)s' is already in index '%(index)s'."
+
+    def __init__(self, key, index):
+        errors.BzrError.__init__(self)
+        self.key = key
+        self.index = index
+
+
+class BadIndexKey(errors.BzrError):
+
+    _fmt = "The key '%(key)s' is not a valid key."
+
+    def __init__(self, key):
+        errors.BzrError.__init__(self)
+        self.key = key
+
+
+class BadIndexOptions(errors.BzrError):
+
+    _fmt = "Could not parse options for index %(value)s."
+
+    def __init__(self, value):
+        errors.BzrError.__init__(self)
+        self.value = value
+
+
+class BadIndexValue(errors.BzrError):
+
+    _fmt = "The value '%(value)s' is not a valid value."
+
+    def __init__(self, value):
+        errors.BzrError.__init__(self)
+        self.value = value
+
+
 _whitespace_re = re.compile(b'[\t\n\x0b\x0c\r\x00 ]')
 _newline_null_re = re.compile(b'[\n\0]')
 
@@ -112,12 +167,12 @@
     def _check_key(self, key):
         """Raise BadIndexKey if key is not a valid key for this index."""
         if type(key) not in (tuple, StaticTuple):
-            raise errors.BadIndexKey(key)
+            raise BadIndexKey(key)
         if self._key_length != len(key):
-            raise errors.BadIndexKey(key)
+            raise BadIndexKey(key)
         for element in key:
             if not element or _whitespace_re.search(element) is not None:
-                raise errors.BadIndexKey(element)
+                raise BadIndexKey(element)
 
     def _external_references(self):
         """Return references that are not present in this index.
@@ -201,9 +256,9 @@
         as_st = StaticTuple.from_sequence
         self._check_key(key)
         if _newline_null_re.search(value) is not None:
-            raise errors.BadIndexValue(value)
+            raise BadIndexValue(value)
         if len(references) != self.reference_lists:
-            raise errors.BadIndexValue(references)
+            raise BadIndexValue(references)
         node_refs = []
         absent_references = []
         for reference_list in references:
@@ -232,7 +287,7 @@
         (node_refs,
          absent_references) = self._check_key_ref_value(key, references, value)
         if key in self._nodes and self._nodes[key][0] != 'a':
-            raise errors.BadIndexDuplicateKey(key, self)
+            raise BadIndexDuplicateKey(key, self)
         for reference in absent_references:
             # There may be duplicates, but I don't think it is worth worrying
             # about
@@ -492,7 +547,7 @@
         # cache the keys for quick set intersections
         if trailers != 1:
             # there must be one line - the empty trailer line.
-            raise errors.BadIndexData(self)
+            raise BadIndexData(self)
 
     def clear_cache(self):
         """Clear out any cached/memoized values.
@@ -558,28 +613,28 @@
     def _read_prefix(self, stream):
         signature = stream.read(len(self._signature()))
         if not signature == self._signature():
-            raise errors.BadIndexFormatSignature(self._name, GraphIndex)
+            raise BadIndexFormatSignature(self._name, GraphIndex)
         options_line = stream.readline()
         if not options_line.startswith(_OPTION_NODE_REFS):
-            raise errors.BadIndexOptions(self)
+            raise BadIndexOptions(self)
         try:
             self.node_ref_lists = int(options_line[len(_OPTION_NODE_REFS):-1])
         except ValueError:
-            raise errors.BadIndexOptions(self)
+            raise BadIndexOptions(self)
         options_line = stream.readline()
         if not options_line.startswith(_OPTION_KEY_ELEMENTS):
-            raise errors.BadIndexOptions(self)
+            raise BadIndexOptions(self)
         try:
             self._key_length = int(options_line[len(_OPTION_KEY_ELEMENTS):-1])
         except ValueError:
-            raise errors.BadIndexOptions(self)
+            raise BadIndexOptions(self)
         options_line = stream.readline()
         if not options_line.startswith(_OPTION_LEN):
-            raise errors.BadIndexOptions(self)
+            raise BadIndexOptions(self)
         try:
             self._key_count = int(options_line[len(_OPTION_LEN):-1])
         except ValueError:
-            raise errors.BadIndexOptions(self)
+            raise BadIndexOptions(self)
 
     def _resolve_references(self, references):
         """Return the resolved key references for references.
@@ -906,29 +961,29 @@
         """
         signature = bytes[0:len(self._signature())]
         if not signature == self._signature():
-            raise errors.BadIndexFormatSignature(self._name, GraphIndex)
+            raise BadIndexFormatSignature(self._name, GraphIndex)
         lines = bytes[len(self._signature()):].splitlines()
         options_line = lines[0]
         if not options_line.startswith(_OPTION_NODE_REFS):
-            raise errors.BadIndexOptions(self)
+            raise BadIndexOptions(self)
         try:
             self.node_ref_lists = int(options_line[len(_OPTION_NODE_REFS):])
         except ValueError:
-            raise errors.BadIndexOptions(self)
+            raise BadIndexOptions(self)
         options_line = lines[1]
         if not options_line.startswith(_OPTION_KEY_ELEMENTS):
-            raise errors.BadIndexOptions(self)
+            raise BadIndexOptions(self)
         try:
             self._key_length = int(options_line[len(_OPTION_KEY_ELEMENTS):])
         except ValueError:
-            raise errors.BadIndexOptions(self)
+            raise BadIndexOptions(self)
         options_line = lines[2]
         if not options_line.startswith(_OPTION_LEN):
-            raise errors.BadIndexOptions(self)
+            raise BadIndexOptions(self)
         try:
             self._key_count = int(options_line[len(_OPTION_LEN):])
         except ValueError:
-            raise errors.BadIndexOptions(self)
+            raise BadIndexOptions(self)
         # calculate the bytes we have processed
         header_end = (len(signature) + len(lines[0]) + len(lines[1]) +
             len(lines[2]) + 3)
@@ -1087,7 +1142,7 @@
                 continue
             elements = line.split('\0')
             if len(elements) != self._expected_elements:
-                raise errors.BadIndexData(self)
+                raise BadIndexData(self)
             # keys are tuples. Each element is a string that may occur many
             # times, so we intern them to save space. AB, RC, 200807
             key = tuple([intern(element) for element in elements[:self._key_length]])
@@ -1739,11 +1794,11 @@
         for node in an_iter:
             # cross checks
             if node[1][:self.prefix_len] != self.prefix:
-                raise errors.BadIndexData(self)
+                raise BadIndexData(self)
             for ref_list in node[3]:
                 for ref_node in ref_list:
                     if ref_node[:self.prefix_len] != self.prefix:
-                        raise errors.BadIndexData(self)
+                        raise BadIndexData(self)
             yield node[0], node[1][self.prefix_len:], node[2], (
                 tuple(tuple(ref_node[self.prefix_len:] for ref_node in ref_list)
                 for ref_list in node[3]))
@@ -1807,9 +1862,9 @@
 def _sanity_check_key(index_or_builder, key):
     """Raise BadIndexKey if key cannot be used for prefix matching."""
     if key[0] is None:
-        raise errors.BadIndexKey(key)
+        raise BadIndexKey(key)
     if len(key) != index_or_builder._key_length:
-        raise errors.BadIndexKey(key)
+        raise BadIndexKey(key)
 
 
 def _iter_entries_prefix(index_or_builder, nodes_by_key, keys):

=== modified file 'breezy/bzr/remote.py'
--- breezy/bzr/remote.py	2017-06-22 01:06:22 +0000
+++ breezy/bzr/remote.py	2017-07-24 01:10:54 +0000
@@ -3362,7 +3362,7 @@
         # the vfs branch.
         try:
             fallback_url = self.get_stacked_on_url()
-        except (errors.NotStacked, errors.UnstackableBranchFormat,
+        except (errors.NotStacked, branch.UnstackableBranchFormat,
             errors.UnstackableRepositoryFormat) as e:
             return
         self._is_stacked = True
@@ -4234,7 +4234,7 @@
 no_context_error_translators.register('TipChangeRejected',
     lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
 no_context_error_translators.register('UnstackableBranchFormat',
-    lambda err: errors.UnstackableBranchFormat(*err.error_args))
+    lambda err: branch.UnstackableBranchFormat(*err.error_args))
 no_context_error_translators.register('UnstackableRepositoryFormat',
     lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
 no_context_error_translators.register('FileExists',

=== modified file 'breezy/bzr/smart/request.py'
--- breezy/bzr/smart/request.py	2017-07-21 13:51:15 +0000
+++ breezy/bzr/smart/request.py	2017-07-24 01:10:54 +0000
@@ -36,6 +36,7 @@
 import threading
 
 from ... import (
+    branch as _mod_branch,
     debug,
     errors,
     osutils,
@@ -430,7 +431,7 @@
         return ('RevisionNotPresent', err.revision_id, err.file_id)
     elif isinstance(err, errors.UnstackableRepositoryFormat):
         return (('UnstackableRepositoryFormat', str(err.format), err.url))
-    elif isinstance(err, errors.UnstackableBranchFormat):
+    elif isinstance(err, _mod_branch.UnstackableBranchFormat):
         return ('UnstackableBranchFormat', str(err.format), err.url)
     elif isinstance(err, errors.NotStacked):
         return ('NotStacked',)

=== modified file 'breezy/commit.py'
--- breezy/commit.py	2017-06-20 22:54:06 +0000
+++ breezy/commit.py	2017-07-24 01:10:54 +0000
@@ -60,7 +60,7 @@
 from .branch import Branch
 from .cleanup import OperationWithCleanups
 import breezy.config
-from .errors import (BzrError, PointlessCommit,
+from .errors import (BzrError,
                      ConflictsInTree,
                      StrictCommitFailed
                      )
@@ -75,6 +75,30 @@
 from .i18n import gettext
 
 
+class PointlessCommit(BzrError):
+
+    _fmt = "No changes to commit"
+
+
+class CannotCommitSelectedFileMerge(BzrError):
+
+    _fmt = 'Selected-file commit of merges is not supported yet:'\
+        ' files %(files_str)s'
+
+    def __init__(self, files):
+        files_str = ', '.join(files)
+        BzrError.__init__(self, files=files, files_str=files_str)
+
+
+class ExcludesUnsupported(BzrError):
+
+    _fmt = ('Excluding paths during commit is not supported by '
+            'repository at %(repository)r.')
+
+    def __init__(self, repository):
+        BzrError.__init__(self, repository=repository)
+
+
 def filter_excluded(iter_changes, exclude):
     """Filter exclude filenames.
 

=== modified file 'breezy/controldir.py'
--- breezy/controldir.py	2017-07-15 13:23:08 +0000
+++ breezy/controldir.py	2017-07-24 01:10:54 +0000
@@ -29,7 +29,6 @@
 import textwrap
 
 from breezy import (
-    errors,
     hooks,
     revision as _mod_revision,
     transport as _mod_transport,
@@ -45,7 +44,18 @@
 from breezy.i18n import gettext
 """)
 
-from . import registry
+from . import (
+    errors,
+    registry,
+    )
+
+
+class MustHaveWorkingTree(errors.BzrError):
+
+    _fmt = ("Branching '%(url)s'(%(format)s) must create a working tree.")
+
+    def __init__(self, format, url):
+        errors.BzrError.__init__(self, format=format, url=url)
 
 
 class ControlComponent(object):

=== modified file 'breezy/directory_service.py'
--- breezy/directory_service.py	2017-06-11 00:27:48 +0000
+++ breezy/directory_service.py	2017-07-24 01:10:54 +0000
@@ -36,6 +36,26 @@
 """)
 
 
+class DirectoryLookupFailure(errors.BzrError):
+    """Base type for lookup errors."""
+
+
+class InvalidLocationAlias(DirectoryLookupFailure):
+
+    _fmt = '"%(alias_name)s" is not a valid location alias.'
+
+    def __init__(self, alias_name):
+        DirectoryLookupFailure.__init__(self, alias_name=alias_name)
+
+
+class UnsetLocationAlias(DirectoryLookupFailure):
+
+    _fmt = 'No %(alias_name)s location assigned.'
+
+    def __init__(self, alias_name):
+        DirectoryLookupFailure.__init__(self, alias_name=alias_name[1:])
+
+
 class DirectoryServiceRegistry(registry.Registry):
     """This object maintains and uses a list of directory services.
 
@@ -99,11 +119,11 @@
         try:
             method = self.branch_aliases.get(name[1:])
         except KeyError:
-            raise errors.InvalidLocationAlias(url)
+            raise InvalidLocationAlias(url)
         else:
             result = method(branch)
         if result is None:
-            raise errors.UnsetLocationAlias(url)
+            raise UnsetLocationAlias(url)
         if extra is not None:
             result = urlutils.join(result, extra)
         return result

=== modified file 'breezy/errors.py'
--- breezy/errors.py	2017-07-24 01:07:36 +0000
+++ breezy/errors.py	2017-07-24 01:10:54 +0000
@@ -162,16 +162,6 @@
         self.msg = msg
 
 
-class DirstateCorrupt(BzrError):
-
-    _fmt = "The dirstate file (%(state)s) appears to be corrupt: %(msg)s"
-
-    def __init__(self, state, msg):
-        BzrError.__init__(self)
-        self.state = state
-        self.msg = msg
-
-
 class IncompatibleVersion(BzrError):
 
     _fmt = 'API %(api)s is not compatible; one of versions %(wanted)r '\
@@ -323,62 +313,6 @@
         self.not_locked = not_locked
 
 
-class BadIndexFormatSignature(BzrError):
-
-    _fmt = "%(value)s is not an index of type %(_type)s."
-
-    def __init__(self, value, _type):
-        BzrError.__init__(self)
-        self.value = value
-        self._type = _type
-
-
-class BadIndexData(BzrError):
-
-    _fmt = "Error in data for index %(value)s."
-
-    def __init__(self, value):
-        BzrError.__init__(self)
-        self.value = value
-
-
-class BadIndexDuplicateKey(BzrError):
-
-    _fmt = "The key '%(key)s' is already in index '%(index)s'."
-
-    def __init__(self, key, index):
-        BzrError.__init__(self)
-        self.key = key
-        self.index = index
-
-
-class BadIndexKey(BzrError):
-
-    _fmt = "The key '%(key)s' is not a valid key."
-
-    def __init__(self, key):
-        BzrError.__init__(self)
-        self.key = key
-
-
-class BadIndexOptions(BzrError):
-
-    _fmt = "Could not parse options for index %(value)s."
-
-    def __init__(self, value):
-        BzrError.__init__(self)
-        self.value = value
-
-
-class BadIndexValue(BzrError):
-
-    _fmt = "The value '%(value)s' is not a valid value."
-
-    def __init__(self, value):
-        BzrError.__init__(self)
-        self.value = value
-
-
 class StrictCommitFailed(BzrError):
 
     _fmt = "Commit refused because there are unknown files in the tree"
@@ -482,16 +416,6 @@
         self.key = key
 
 
-class UnknownHook(BzrError):
-
-    _fmt = "The %(type)s hook '%(hook)s' is unknown in this version of breezy."
-
-    def __init__(self, hook_type, hook_name):
-        BzrError.__init__(self)
-        self.type = hook_type
-        self.hook = hook_name
-
-
 class UnsupportedProtocol(PathError):
 
     _fmt = 'Unsupported protocol for url "%(path)s"%(extra)s'
@@ -500,17 +424,6 @@
         PathError.__init__(self, url, extra=extra)
 
 
-class UnstackableBranchFormat(BzrError):
-
-    _fmt = ("The branch '%(url)s'(%(format)s) is not a stackable format. "
-        "You will need to upgrade the branch to permit branch stacking.")
-
-    def __init__(self, format, url):
-        BzrError.__init__(self)
-        self.format = format
-        self.url = url
-
-
 class UnstackableLocationError(BzrError):
 
     _fmt = "The branch '%(branch_url)s' cannot be stacked on '%(target_url)s'."
@@ -1018,36 +931,6 @@
         self.lock_token = lock_token
 
 
-class PointlessCommit(BzrError):
-
-    _fmt = "No changes to commit"
-
-
-class CannotCommitSelectedFileMerge(BzrError):
-
-    _fmt = 'Selected-file commit of merges is not supported yet:'\
-        ' files %(files_str)s'
-
-    def __init__(self, files):
-        files_str = ', '.join(files)
-        BzrError.__init__(self, files=files, files_str=files_str)
-
-
-class ExcludesUnsupported(BzrError):
-
-    _fmt = ('Excluding paths during commit is not supported by '
-            'repository at %(repository)r.')
-
-    def __init__(self, repository):
-        BzrError.__init__(self, repository=repository)
-
-
-class BadCommitMessageEncoding(BzrError):
-
-    _fmt = 'The specified commit message contains characters unsupported by '\
-        'the current encoding.'
-
-
 class UpgradeReadonly(BzrError):
 
     _fmt = "Upgrade URL cannot work with readonly URLs."
@@ -1062,11 +945,6 @@
         self.format = format
 
 
-class StrictCommitFailed(Exception):
-
-    _fmt = "Commit refused because there are unknowns in the tree."
-
-
 class NoSuchRevision(InternalBzrError):
 
     _fmt = "%(branch)s has no revision %(revision)s"
@@ -1992,17 +1870,6 @@
     _fmt = "Format error in conflict listings"
 
 
-class CorruptDirstate(BzrError):
-
-    _fmt = ("Inconsistency in dirstate file %(dirstate_path)s.\n"
-            "Error: %(description)s")
-
-    def __init__(self, dirstate_path, description):
-        BzrError.__init__(self)
-        self.dirstate_path = dirstate_path
-        self.description = description
-
-
 class CorruptRepository(BzrError):
 
     _fmt = ("An error has been detected in the repository %(repo_path)s.\n"
@@ -2492,79 +2359,6 @@
         self.reason = reason
 
 
-class BzrDirError(BzrError):
-
-    def __init__(self, controldir):
-        from . import urlutils
-        display_url = urlutils.unescape_for_display(controldir.user_url,
-                                                    'ascii')
-        BzrError.__init__(self, controldir=controldir, display_url=display_url)
-
-
-class UnsyncedBranches(BzrDirError):
-
-    _fmt = ("'%(display_url)s' is not in sync with %(target_url)s.  See"
-            " brz help sync-for-reconfigure.")
-
-    def __init__(self, controldir, target_branch):
-        BzrError.__init__(self, controldir)
-        from . import urlutils
-        self.target_url = urlutils.unescape_for_display(target_branch.base,
-                                                        'ascii')
-
-
-class AlreadyBranch(BzrDirError):
-
-    _fmt = "'%(display_url)s' is already a branch."
-
-
-class AlreadyTree(BzrDirError):
-
-    _fmt = "'%(display_url)s' is already a tree."
-
-
-class AlreadyCheckout(BzrDirError):
-
-    _fmt = "'%(display_url)s' is already a checkout."
-
-
-class AlreadyLightweightCheckout(BzrDirError):
-
-    _fmt = "'%(display_url)s' is already a lightweight checkout."
-
-
-class AlreadyUsingShared(BzrDirError):
-
-    _fmt = "'%(display_url)s' is already using a shared repository."
-
-
-class AlreadyStandalone(BzrDirError):
-
-    _fmt = "'%(display_url)s' is already standalone."
-
-
-class AlreadyWithTrees(BzrDirError):
-
-    _fmt = ("Shared repository '%(display_url)s' already creates "
-            "working trees.")
-
-
-class AlreadyWithNoTrees(BzrDirError):
-
-    _fmt = ("Shared repository '%(display_url)s' already doesn't create "
-            "working trees.")
-
-
-class ReconfigurationNotSupported(BzrDirError):
-
-    _fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
-
-
-class NoBindLocation(BzrDirError):
-
-    _fmt = "No location could be found to bind to at %(display_url)s."
-
-
 class UncommittedChanges(BzrError):
 
     _fmt = ('Working tree "%(display_url)s" has uncommitted changes'
@@ -2605,19 +2399,6 @@
             ' (See brz shelve --list).%(more)s')
 
 
-class MissingTemplateVariable(BzrError):
-
-    _fmt = 'Variable {%(name)s} is not available.'
-
-    def __init__(self, name):
-        self.name = name
-
-
-class NoTemplate(BzrError):
-
-    _fmt = 'No template specified.'
-
-
 class UnableCreateSymlink(BzrError):
 
     _fmt = 'Unable to create symlink %(path_str)son this platform'
@@ -2633,15 +2414,6 @@
         self.path_str = path_str
 
 
-class UnsupportedTimezoneFormat(BzrError):
-
-    _fmt = ('Unsupported timezone format "%(timezone)s", '
-            'options are "utc", "original", "local".')
-
-    def __init__(self, timezone):
-        self.timezone = timezone
-
-
 class UnableEncodePath(BzrError):
 
     _fmt = ('Unable to encode %(kind)s path %(path)r in '
@@ -2662,28 +2434,6 @@
         BzrError.__init__(self, alias_name=alias_name)
 
 
-class DirectoryLookupFailure(BzrError):
-    """Base type for lookup errors."""
-
-    pass
-
-
-class InvalidLocationAlias(DirectoryLookupFailure):
-
-    _fmt = '"%(alias_name)s" is not a valid location alias.'
-
-    def __init__(self, alias_name):
-        DirectoryLookupFailure.__init__(self, alias_name=alias_name)
-
-
-class UnsetLocationAlias(DirectoryLookupFailure):
-
-    _fmt = 'No %(alias_name)s location assigned.'
-
-    def __init__(self, alias_name):
-        DirectoryLookupFailure.__init__(self, alias_name=alias_name[1:])
-
-
 class CannotBindAddress(BzrError):
 
     _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
@@ -2694,14 +2444,6 @@
             orig_error=repr(orig_error.args))
 
 
-class UnknownRules(BzrError):
-
-    _fmt = ('Unknown rules detected: %(unknowns_str)s.')
-
-    def __init__(self, unknowns):
-        BzrError.__init__(self, unknowns_str=", ".join(unknowns))
-
-
 class TipChangeRejected(BzrError):
     """A pre_change_branch_tip hook function may raise this to cleanly and
     explicitly abort a change to a branch tip.
@@ -2713,18 +2455,6 @@
         self.msg = msg
 
 
-class DecompressCorruption(BzrError):
-
-    _fmt = "Corruption while decompressing repository file%(orig_error)s"
-
-    def __init__(self, orig_error=None):
-        if orig_error is not None:
-            self.orig_error = ", %s" % (orig_error,)
-        else:
-            self.orig_error = ""
-        BzrError.__init__(self)
-
-
 class JailBreak(BzrError):
 
     _fmt = "An attempt to access a url outside the server jail was made: '%(url)s'."
@@ -2738,14 +2468,6 @@
     _fmt = 'The user aborted the operation.'
 
 
-class MustHaveWorkingTree(BzrError):
-
-    _fmt = ("Branching '%(url)s'(%(format)s) must create a working tree.")
-
-    def __init__(self, format, url):
-        BzrError.__init__(self, format=format, url=url)
-
-
 class UnresumableWriteGroup(BzrError):
 
     _fmt = ("Repository %(repository)s cannot resume write group "
@@ -2822,14 +2544,6 @@
         self.format = format
 
 
-class FeatureAlreadyRegistered(BzrError):
-
-    _fmt = 'The feature %(feature)s has already been registered.'
-
-    def __init__(self, feature):
-        self.feature = feature
-
-
 class ChangesAlreadyStored(BzrCommandError):
 
     _fmt = ('Cannot store uncommitted changes because this branch already'

=== modified file 'breezy/hooks.py'
--- breezy/hooks.py	2017-06-11 20:15:04 +0000
+++ breezy/hooks.py	2017-07-24 01:10:54 +0000
@@ -19,6 +19,7 @@
 from __future__ import absolute_import
 
 from . import (
+    errors,
     registry,
     )
 from .lazy_import import lazy_import
@@ -27,13 +28,22 @@
 
 from breezy import (
     _format_version_tuple,
-    errors,
     pyutils,
     )
 from breezy.i18n import gettext
 """)
 
 
+class UnknownHook(errors.BzrError):
+
+    _fmt = "The %(type)s hook '%(hook)s' is unknown in this version of breezy."
+
+    def __init__(self, hook_type, hook_name):
+        errors.BzrError.__init__(self)
+        self.type = hook_type
+        self.hook = hook_name
+
+
 class KnownHooksRegistry(registry.Registry):
     # known_hooks registry contains
     # tuple of (module, member name) which is the hook point
@@ -204,7 +214,7 @@
         try:
             hook = self[hook_name]
         except KeyError:
-            raise errors.UnknownHook(self.__class__.__name__, hook_name)
+            raise UnknownHook(self.__class__.__name__, hook_name)
         try:
             hook_lazy = getattr(hook, "hook_lazy")
         except AttributeError:
@@ -229,7 +239,7 @@
         try:
             hook = self[hook_name]
         except KeyError:
-            raise errors.UnknownHook(self.__class__.__name__, hook_name)
+            raise UnknownHook(self.__class__.__name__, hook_name)
         try:
             # list hooks, old-style, not yet deprecated but less useful.
             hook.append(a_callable)
@@ -247,7 +257,7 @@
         try:
             hook = self[hook_name]
         except KeyError:
-            raise errors.UnknownHook(self.__class__.__name__, hook_name)
+            raise UnknownHook(self.__class__.__name__, hook_name)
         try:
             uninstall = getattr(hook, "uninstall")
         except AttributeError:

=== modified file 'breezy/info.py'
--- breezy/info.py	2017-07-15 13:23:08 +0000
+++ breezy/info.py	2017-07-24 01:10:54 +0000
@@ -22,6 +22,7 @@
 import sys
 
 from . import (
+    branch as _mod_branch,
     controldir,
     errors,
     hooks as _mod_hooks,
@@ -162,7 +163,7 @@
     locs.add_url('submit branch', branch.get_submit_branch())
     try:
         locs.add_url('stacked on', branch.get_stacked_on_url())
-    except (errors.UnstackableBranchFormat, errors.UnstackableRepositoryFormat,
+    except (_mod_branch.UnstackableBranchFormat, errors.UnstackableRepositoryFormat,
         errors.NotStacked):
         pass
     return locs

=== modified file 'breezy/msgeditor.py'
--- breezy/msgeditor.py	2017-05-22 00:56:52 +0000
+++ breezy/msgeditor.py	2017-07-24 01:10:54 +0000
@@ -31,13 +31,19 @@
     transport,
     ui,
     )
-from .errors import BzrError, BadCommitMessageEncoding
+from .errors import BzrError
 from .hooks import Hooks
 from .sixish import (
     StringIO,
     )
 
 
+class BadCommitMessageEncoding(BzrError):
+
+    _fmt = 'The specified commit message contains characters unsupported by '\
+        'the current encoding.'
+
+
 def _get_editor():
     """Return a sequence of possible editor binaries for the current platform"""
     try:

=== modified file 'breezy/osutils.py'
--- breezy/osutils.py	2017-06-15 23:20:39 +0000
+++ breezy/osutils.py	2017-07-24 01:10:54 +0000
@@ -47,7 +47,6 @@
 
 from breezy import (
     config,
-    errors,
     trace,
     win32utils,
     )
@@ -66,7 +65,10 @@
 
 
 import breezy
-from . import _fs_enc
+from . import (
+    _fs_enc,
+    errors,
+    )
 
 
 # Cross platform wall-clock time functionality with decent resolution.
@@ -89,6 +91,15 @@
 O_NOINHERIT = getattr(os, 'O_NOINHERIT', 0)
 
 
+class UnsupportedTimezoneFormat(errors.BzrError):
+
+    _fmt = ('Unsupported timezone format "%(timezone)s", '
+            'options are "utc", "original", "local".')
+
+    def __init__(self, timezone):
+        self.timezone = timezone
+
+
 def get_unicode_argv():
     if PY3:
         return sys.argv[1:]
@@ -899,7 +910,7 @@
         tt = time.localtime(t)
         offset = local_time_offset(t)
     else:
-        raise errors.UnsupportedTimezoneFormat(timezone)
+        raise UnsupportedTimezoneFormat(timezone)
     if date_fmt is None:
         date_fmt = "%a %Y-%m-%d %H:%M:%S"
     if show_offset:

=== modified file 'breezy/plugins/weave_fmt/bzrdir.py'
--- breezy/plugins/weave_fmt/bzrdir.py	2017-06-11 20:33:20 +0000
+++ breezy/plugins/weave_fmt/bzrdir.py	2017-07-24 01:10:54 +0000
@@ -26,15 +26,19 @@
 from ...controldir import (
     ControlDir,
     Converter,
+    MustHaveWorkingTree,
     format_registry,
     )
+from ... import (
+    errors,
+    )
 from ...lazy_import import lazy_import
 lazy_import(globals(), """
 import os
 import warnings
 
 from breezy import (
-    errors,
+    branch as _mod_branch,,
     graph,
     lockable_files,
     lockdir,
@@ -903,10 +907,10 @@
                     "source branch %r is not within %r with branch %r" %
                     (source_branch, self, my_branch))
         if stacked:
-            raise errors.UnstackableBranchFormat(
+            raise _mod_branch.UnstackableBranchFormat(
                 self._format, self.root_transport.base)
         if not create_tree_if_local:
-            raise errors.MustHaveWorkingTree(
+            raise MustHaveWorkingTree(
                 self._format, self.root_transport.base)
         from .workingtree import WorkingTreeFormat2
         self._make_tail(url)

=== modified file 'breezy/push.py'
--- breezy/push.py	2017-06-11 00:27:48 +0000
+++ breezy/push.py	2017-07-24 01:10:54 +0000
@@ -19,6 +19,7 @@
 from __future__ import absolute_import
 
 from . import (
+    branch as _mod_branch,
     controldir,
     errors,
     revision as _mod_revision,
@@ -125,7 +126,7 @@
         # TODO: Some more useful message about what was copied
         try:
             push_result.stacked_on = br_to.get_stacked_on_url()
-        except (errors.UnstackableBranchFormat,
+        except (_mod_branch.UnstackableBranchFormat,
                 errors.UnstackableRepositoryFormat,
                 errors.NotStacked):
             push_result.stacked_on = None

=== modified file 'breezy/reconfigure.py'
--- breezy/reconfigure.py	2017-06-11 00:27:48 +0000
+++ breezy/reconfigure.py	2017-07-24 01:10:54 +0000
@@ -37,6 +37,79 @@
 # assumptions about what kind of change will be done.
 
 
+class BzrDirError(errors.BzrError):
+
+    def __init__(self, controldir):
+        display_url = urlutils.unescape_for_display(controldir.user_url,
+                                                    'ascii')
+        errors.BzrError.__init__(self, controldir=controldir,
+                                 display_url=display_url)
+
+
+class NoBindLocation(BzrDirError):
+
+    _fmt = "No location could be found to bind to at %(display_url)s."
+
+
+class UnsyncedBranches(BzrDirError):
+
+    _fmt = ("'%(display_url)s' is not in sync with %(target_url)s.  See"
+            " brz help sync-for-reconfigure.")
+
+    def __init__(self, controldir, target_branch):
+        BzrError.__init__(self, controldir)
+        from . import urlutils
+        self.target_url = urlutils.unescape_for_display(target_branch.base,
+                                                        'ascii')
+
+
+class AlreadyBranch(BzrDirError):
+
+    _fmt = "'%(display_url)s' is already a branch."
+
+
+class AlreadyTree(BzrDirError):
+
+    _fmt = "'%(display_url)s' is already a tree."
+
+
+class AlreadyCheckout(BzrDirError):
+
+    _fmt = "'%(display_url)s' is already a checkout."
+
+
+class AlreadyLightweightCheckout(BzrDirError):
+
+    _fmt = "'%(display_url)s' is already a lightweight checkout."
+
+
+class AlreadyUsingShared(BzrDirError):
+
+    _fmt = "'%(display_url)s' is already using a shared repository."
+
+
+class AlreadyStandalone(BzrDirError):
+
+    _fmt = "'%(display_url)s' is already standalone."
+
+
+class AlreadyWithTrees(BzrDirError):
+
+    _fmt = ("Shared repository '%(display_url)s' already creates "
+            "working trees.")
+
+
+class AlreadyWithNoTrees(BzrDirError):
+
+    _fmt = ("Shared repository '%(display_url)s' already doesn't create "
+            "working trees.")
+
+
+class ReconfigurationNotSupported(BzrDirError):
+
+    _fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
+
+
 class ReconfigureStackedOn(object):
     """Reconfigures a branch to be stacked on another branch."""
 
@@ -120,13 +193,13 @@
         """Return a Reconfiguration to convert this controldir into a branch
 
         :param controldir: The controldir to reconfigure
-        :raise errors.AlreadyBranch: if controldir is already a branch
+        :raise AlreadyBranch: if controldir is already a branch
         """
         reconfiguration = Reconfigure(controldir)
         reconfiguration._plan_changes(want_tree=False, want_branch=True,
                                       want_bound=False, want_reference=False)
         if not reconfiguration.changes_planned():
-            raise errors.AlreadyBranch(controldir)
+            raise AlreadyBranch(controldir)
         return reconfiguration
 
     @staticmethod
@@ -134,13 +207,13 @@
         """Return a Reconfiguration to convert this controldir into a tree
 
         :param controldir: The controldir to reconfigure
-        :raise errors.AlreadyTree: if controldir is already a tree
+        :raise AlreadyTree: if controldir is already a tree
         """
         reconfiguration = Reconfigure(controldir)
         reconfiguration._plan_changes(want_tree=True, want_branch=True,
                                       want_bound=False, want_reference=False)
         if not reconfiguration.changes_planned():
-            raise errors.AlreadyTree(controldir)
+            raise AlreadyTree(controldir)
         return reconfiguration
 
     @staticmethod
@@ -149,13 +222,13 @@
 
         :param controldir: The controldir to reconfigure
         :param bound_location: The location the checkout should be bound to.
-        :raise errors.AlreadyCheckout: if controldir is already a checkout
+        :raise AlreadyCheckout: if controldir is already a checkout
         """
         reconfiguration = Reconfigure(controldir, bound_location)
         reconfiguration._plan_changes(want_tree=True, want_branch=True,
                                       want_bound=True, want_reference=False)
         if not reconfiguration.changes_planned():
-            raise errors.AlreadyCheckout(controldir)
+            raise AlreadyCheckout(controldir)
         return reconfiguration
 
     @classmethod
@@ -164,14 +237,14 @@
 
         :param controldir: The controldir to reconfigure
         :param bound_location: The location the checkout should be bound to.
-        :raise errors.AlreadyLightweightCheckout: if controldir is already a
+        :raise AlreadyLightweightCheckout: if controldir is already a
             lightweight checkout
         """
         reconfiguration = klass(controldir, reference_location)
         reconfiguration._plan_changes(want_tree=True, want_branch=False,
                                       want_bound=False, want_reference=True)
         if not reconfiguration.changes_planned():
-            raise errors.AlreadyLightweightCheckout(controldir)
+            raise AlreadyLightweightCheckout(controldir)
         return reconfiguration
 
     @classmethod
@@ -180,7 +253,7 @@
         reconfiguration = klass(controldir)
         reconfiguration._set_use_shared(use_shared=True)
         if not reconfiguration.changes_planned():
-            raise errors.AlreadyUsingShared(controldir)
+            raise AlreadyUsingShared(controldir)
         return reconfiguration
 
     @classmethod
@@ -189,7 +262,7 @@
         reconfiguration = klass(controldir)
         reconfiguration._set_use_shared(use_shared=False)
         if not reconfiguration.changes_planned():
-            raise errors.AlreadyStandalone(controldir)
+            raise AlreadyStandalone(controldir)
         return reconfiguration
 
     @classmethod
@@ -197,12 +270,12 @@
         """Adjust a repository's working tree presence default"""
         reconfiguration = klass(controldir)
         if not reconfiguration.repository.is_shared():
-            raise errors.ReconfigurationNotSupported(reconfiguration.controldir)
+            raise ReconfigurationNotSupported(reconfiguration.controldir)
         if with_trees and reconfiguration.repository.make_working_trees():
-            raise errors.AlreadyWithTrees(controldir)
+            raise AlreadyWithTrees(controldir)
         elif (not with_trees
               and not reconfiguration.repository.make_working_trees()):
-            raise errors.AlreadyWithNoTrees(controldir)
+            raise AlreadyWithNoTrees(controldir)
         else:
             reconfiguration._repository_trees = with_trees
         return reconfiguration
@@ -211,9 +284,9 @@
                       want_reference):
         """Determine which changes are needed to assume the configuration"""
         if not want_branch and not want_reference:
-            raise errors.ReconfigurationNotSupported(self.controldir)
+            raise ReconfigurationNotSupported(self.controldir)
         if want_branch and want_reference:
-            raise errors.ReconfigurationNotSupported(self.controldir)
+            raise ReconfigurationNotSupported(self.controldir)
         if self.repository is None:
             if not want_reference:
                 self._create_repository = True
@@ -302,7 +375,7 @@
                 return parent
         elif self.referenced_branch is not None:
             return self.referenced_branch.base
-        raise errors.NoBindLocation(self.controldir)
+        raise NoBindLocation(self.controldir)
 
     def apply(self, force=False):
         """Apply the reconfiguration
@@ -311,7 +384,7 @@
             destroy local changes.
         :raise errors.UncommittedChanges: if the local tree is to be destroyed
             but contains uncommitted changes.
-        :raise errors.NoBindLocation: if no bind location was specified and
+        :raise NoBindLocation: if no bind location was specified and
             none could be autodetected.
         """
         if not force:

=== modified file 'breezy/rules.py'
--- breezy/rules.py	2017-05-22 00:56:52 +0000
+++ breezy/rules.py	2017-07-24 01:10:54 +0000
@@ -43,6 +43,14 @@
 _per_user_searcher = None
 
 
+class UnknownRules(errors.BzrError):
+
+    _fmt = ('Unknown rules detected: %(unknowns_str)s.')
+
+    def __init__(self, unknowns):
+        errors.BzrError.__init__(self, unknowns_str=", ".join(unknowns))
+
+
 class _RulesSearcher(object):
     """An object that provides rule-based preferences."""
 

=== modified file 'breezy/tests/blackbox/test_push.py'
--- breezy/tests/blackbox/test_push.py	2017-06-10 16:40:42 +0000
+++ breezy/tests/blackbox/test_push.py	2017-07-24 01:10:54 +0000
@@ -561,7 +561,7 @@
         self.make_branch('from', format='pack-0.92')
         out, err = self.run_bzr('push -d from to')
         b = branch.Branch.open('to')
-        self.assertRaises(errors.UnstackableBranchFormat, b.get_stacked_on_url)
+        self.assertRaises(branch.UnstackableBranchFormat, b.get_stacked_on_url)
 
     def test_push_doesnt_create_broken_branch(self):
         """Pushing a new standalone branch works even when there's a default

=== modified file 'breezy/tests/per_branch/test_create_clone.py'
--- breezy/tests/per_branch/test_create_clone.py	2017-06-11 14:07:05 +0000
+++ breezy/tests/per_branch/test_create_clone.py	2017-07-24 01:10:54 +0000
@@ -101,7 +101,7 @@
         try:
             result = tree.branch.create_clone_on_transport(target_transport,
                 stacked_on=trunk.base)
-        except errors.UnstackableBranchFormat:
+        except branch.UnstackableBranchFormat:
             if not trunk.repository._format.supports_full_versioned_files:
                 raise tests.TestNotApplicable("can not stack on format")
             raise
@@ -142,7 +142,7 @@
         try:
             result = tree.branch.create_clone_on_transport(target_transport,
                 stacked_on=trunk.base)
-        except errors.UnstackableBranchFormat:
+        except branch.UnstackableBranchFormat:
             if not trunk.repository._format.supports_full_versioned_files:
                 raise tests.TestNotApplicable("can not stack on format")
             raise

=== modified file 'breezy/tests/per_branch/test_sprout.py'
--- breezy/tests/per_branch/test_sprout.py	2017-06-11 14:07:05 +0000
+++ breezy/tests/per_branch/test_sprout.py	2017-07-24 01:10:54 +0000
@@ -209,7 +209,7 @@
             dir = source.controldir.sprout(target_transport.base,
                 source.last_revision(), possible_transports=[target_transport],
                 source_branch=source, stacked=True)
-        except errors.UnstackableBranchFormat:
+        except _mod_branch.UnstackableBranchFormat:
             if not self.branch_format.supports_stacking():
                 raise tests.TestNotApplicable(
                     "Format doesn't auto stack successfully.")

=== modified file 'breezy/tests/per_branch/test_stacking.py'
--- breezy/tests/per_branch/test_stacking.py	2017-06-10 00:52:37 +0000
+++ breezy/tests/per_branch/test_stacking.py	2017-07-24 01:10:54 +0000
@@ -28,7 +28,7 @@
 
 
 unstackable_format_errors = (
-    errors.UnstackableBranchFormat,
+    branch.UnstackableBranchFormat,
     errors.UnstackableRepositoryFormat,
     )
 
@@ -309,14 +309,14 @@
         cloned_unstacked_bzrdir = stacked_bzrdir.clone('cloned-unstacked',
             preserve_stacking=False)
         unstacked_branch = cloned_unstacked_bzrdir.open_branch()
-        self.assertRaises((errors.NotStacked, errors.UnstackableBranchFormat),
+        self.assertRaises((errors.NotStacked, branch.UnstackableBranchFormat),
                           unstacked_branch.get_stacked_on_url)
 
     def test_no_op_preserve_stacking(self):
         """With no stacking, preserve_stacking should be a no-op."""
         branch = self.make_branch('source')
         cloned_bzrdir = branch.controldir.clone('cloned', preserve_stacking=True)
-        self.assertRaises((errors.NotStacked, errors.UnstackableBranchFormat),
+        self.assertRaises((errors.NotStacked, branch.UnstackableBranchFormat),
                           cloned_bzrdir.open_branch().get_stacked_on_url)
 
     def make_stacked_on_matching(self, source):
@@ -344,7 +344,7 @@
             self.assertEqual('../stack-on', target.get_stacked_on_url())
         else:
             self.assertRaises(
-                errors.UnstackableBranchFormat, target.get_stacked_on_url)
+                branch.UnstackableBranchFormat, target.get_stacked_on_url)
 
     def test_clone_stacking_policy_handling(self):
         """Obey policy where possible, ignore otherwise."""
@@ -361,7 +361,7 @@
             self.assertEqual('../stack-on', target.get_stacked_on_url())
         else:
             self.assertRaises(
-                errors.UnstackableBranchFormat, target.get_stacked_on_url)
+                branch.UnstackableBranchFormat, target.get_stacked_on_url)
 
     def test_sprout_to_smart_server_stacking_policy_handling(self):
         """Obey policy where possible, ignore otherwise."""
@@ -379,7 +379,7 @@
             self.assertEqual('../stack-on', target.get_stacked_on_url())
         else:
             self.assertRaises(
-                errors.UnstackableBranchFormat, target.get_stacked_on_url)
+                branch.UnstackableBranchFormat, target.get_stacked_on_url)
 
     def prepare_stacked_on_fetch(self):
         stack_on = self.make_branch_and_tree('stack-on')

=== modified file 'breezy/tests/per_controldir/test_controldir.py'
--- breezy/tests/per_controldir/test_controldir.py	2017-06-11 14:07:05 +0000
+++ breezy/tests/per_controldir/test_controldir.py	2017-07-24 01:10:54 +0000
@@ -18,6 +18,7 @@
 
 import breezy.branch
 from breezy import (
+    branch as _mod_branch,
     check,
     controldir,
     errors,
@@ -428,7 +429,7 @@
         try:
             child = branch.controldir.clone_on_transport(child_transport,
                                                      stacked_on=branch.base)
-        except (errors.UnstackableBranchFormat,
+        except (_mod_branch.UnstackableBranchFormat,
                 errors.UnstackableRepositoryFormat):
             raise TestNotApplicable("branch or repository format does "
                 "not support stacking")
@@ -995,7 +996,7 @@
         try:
             target = dir.sprout(self.get_url('target'),
                 create_tree_if_local=False)
-        except errors.MustHaveWorkingTree:
+        except controldir.MustHaveWorkingTree:
             raise TestNotApplicable("control dir format requires working tree")
         self.assertPathDoesNotExist('target/foo')
         self.assertEqual(tree.branch.last_revision(),

=== modified file 'breezy/tests/per_foreign_vcs/test_branch.py'
--- breezy/tests/per_foreign_vcs/test_branch.py	2017-06-10 00:52:37 +0000
+++ breezy/tests/per_foreign_vcs/test_branch.py	2017-07-24 01:10:54 +0000
@@ -17,10 +17,11 @@
 
 """Tests specific to Branch implementations that use foreign VCS'es."""
 
-
+from breezy.branch import (
+    UnstackableBranchFormat,
+    )
 from breezy.errors import (
     IncompatibleFormat,
-    UnstackableBranchFormat,
     )
 from breezy.revision import (
     NULL_REVISION,

=== modified file 'breezy/tests/per_workingtree/test_commit.py'
--- breezy/tests/per_workingtree/test_commit.py	2017-06-20 00:26:58 +0000
+++ breezy/tests/per_workingtree/test_commit.py	2017-07-24 01:10:54 +0000
@@ -29,6 +29,11 @@
     transport as _mod_transport,
     ui,
     )
+from breezy.commit import (
+    CannotCommitSelectedFileMerge,
+    ExcludesUnsupported,
+    PointlessCommit,
+    )
 from breezy.tests.per_workingtree import TestCaseWithWorkingTree
 from breezy.tests.testui import ProgressRecordingUIFactory
 
@@ -149,9 +154,9 @@
         wt2.commit('change_right')
         wt.merge_from_branch(wt2.branch)
         try:
-            self.assertRaises(errors.CannotCommitSelectedFileMerge,
+            self.assertRaises(CannotCommitSelectedFileMerge,
                 wt.commit, 'test', exclude=['foo'])
-        except errors.ExcludesUnsupported:
+        except ExcludesUnsupported:
             raise tests.TestNotApplicable("excludes not supported by this "
                 "repository format")
 
@@ -162,9 +167,9 @@
         tree.commit('setup test')
         self.build_tree_contents([('a', 'new contents for "a"\n')])
         try:
-            self.assertRaises(errors.PointlessCommit, tree.commit, 'test',
+            self.assertRaises(PointlessCommit, tree.commit, 'test',
                 exclude=['a'], allow_pointless=False)
-        except errors.ExcludesUnsupported:
+        except ExcludesUnsupported:
             raise tests.TestNotApplicable("excludes not supported by this "
                 "repository format")
 
@@ -174,7 +179,7 @@
         tree.smart_add(['.'])
         try:
             tree.commit('test', exclude=['b', 'c'])
-        except errors.ExcludesUnsupported:
+        except ExcludesUnsupported:
             raise tests.TestNotApplicable("excludes not supported by this "
                 "repository format")
         # If b was excluded it will still be 'added' in status.
@@ -458,7 +463,7 @@
         rev_id = tree.commit('added reference')
         child_revid = subtree.last_revision()
         # now do a no-op commit with allow_pointless=False
-        self.assertRaises(errors.PointlessCommit, tree.commit, '',
+        self.assertRaises(PointlessCommit, tree.commit, '',
             allow_pointless=False)
         self.assertEqual(child_revid, subtree.last_revision())
         self.assertEqual(rev_id, tree.last_revision())

=== modified file 'breezy/tests/test__dirstate_helpers.py'
--- breezy/tests/test__dirstate_helpers.py	2017-06-10 12:50:32 +0000
+++ breezy/tests/test__dirstate_helpers.py	2017-07-24 01:10:54 +0000
@@ -21,7 +21,6 @@
 import time
 
 from .. import (
-    errors,
     osutils,
     tests,
     )
@@ -724,7 +723,7 @@
         finally:
             f.close()
             state.lock_read()
-        e = self.assertRaises(errors.DirstateCorrupt,
+        e = self.assertRaises(dirstate.DirstateCorrupt,
                               state._read_dirblocks_if_needed)
         # Make sure we mention the bogus characters in the error
         self.assertContainsRe(str(e), 'bogus')

=== modified file 'breezy/tests/test_branch.py'
--- breezy/tests/test_branch.py	2017-06-10 16:40:42 +0000
+++ breezy/tests/test_branch.py	2017-07-24 01:10:54 +0000
@@ -44,6 +44,18 @@
     )
 
 
+class ErrorTests(tests.TestCase):
+
+    def test_unstackable_branch_format(self):
+        format = u'foo'
+        url = "/foo"
+        error = _mod_branch.UnstackableBranchFormat(format, url)
+        self.assertEqualDiff(
+            "The branch '/foo'(foo) is not a stackable format. "
+            "You will need to upgrade the branch to permit branch stacking.",
+            str(error))
+
+
 class TestDefaultFormat(tests.TestCase):
 
     def test_default_format(self):
@@ -356,12 +368,12 @@
 
     def test_set_stacked_on_url_errors(self):
         branch = self.make_branch('a', format=self.get_format_name())
-        self.assertRaises(errors.UnstackableBranchFormat,
+        self.assertRaises(_mod_branch.UnstackableBranchFormat,
             branch.set_stacked_on_url, None)
 
     def test_default_stacked_location(self):
         branch = self.make_branch('a', format=self.get_format_name())
-        self.assertRaises(errors.UnstackableBranchFormat, branch.get_stacked_on_url)
+        self.assertRaises(_mod_branch.UnstackableBranchFormat, branch.get_stacked_on_url)
 
 
 class TestBranch7(TestBranch67, tests.TestCaseWithTransport):

=== modified file 'breezy/tests/test_bzrdir.py'
--- breezy/tests/test_bzrdir.py	2017-07-14 20:49:41 +0000
+++ breezy/tests/test_bzrdir.py	2017-07-24 01:10:54 +0000
@@ -560,14 +560,14 @@
         child_branch, new_child_transport = self.prepare_default_stacking(
             child_format='pack-0.92')
         new_child = child_branch.controldir.clone_on_transport(new_child_transport)
-        self.assertRaises(errors.UnstackableBranchFormat,
+        self.assertRaises(branch.UnstackableBranchFormat,
                           new_child.open_branch().get_stacked_on_url)
 
     def test_sprout_ignores_policy_for_unsupported_formats(self):
         child_branch, new_child_transport = self.prepare_default_stacking(
             child_format='pack-0.92')
         new_child = child_branch.controldir.sprout(new_child_transport.base)
-        self.assertRaises(errors.UnstackableBranchFormat,
+        self.assertRaises(branch.UnstackableBranchFormat,
                           new_child.open_branch().get_stacked_on_url)
 
     def test_sprout_upgrades_format_if_stacked_specified(self):
@@ -1556,7 +1556,7 @@
         # a feature can only be registered once
         self.addCleanup(SampleBzrFormat.unregister_feature, "nested-trees")
         SampleBzrFormat.register_feature("nested-trees")
-        self.assertRaises(errors.FeatureAlreadyRegistered,
+        self.assertRaises(bzrdir.FeatureAlreadyRegistered,
             SampleBzrFormat.register_feature, "nested-trees")
 
     def test_feature_with_space(self):

=== modified file 'breezy/tests/test_commit.py'
--- breezy/tests/test_commit.py	2017-07-04 20:03:11 +0000
+++ breezy/tests/test_commit.py	2017-07-24 01:10:54 +0000
@@ -26,12 +26,13 @@
 from ..branch import Branch
 from ..bzr.bzrdir import BzrDirMetaFormat1
 from ..commit import (
+    CannotCommitSelectedFileMerge,
     Commit,
     NullCommitReporter,
+    PointlessCommit,
     filter_excluded,
     )
 from ..errors import (
-    PointlessCommit,
     BzrError,
     LockContention,
     )
@@ -763,7 +764,7 @@
         tree.add_parent_tree_id('example')
         self.build_tree(['foo/bar', 'foo/baz'])
         tree.add(['bar', 'baz'])
-        err = self.assertRaises(errors.CannotCommitSelectedFileMerge,
+        err = self.assertRaises(CannotCommitSelectedFileMerge,
             tree.commit, 'commit 2', specific_files=['bar', 'baz'])
         self.assertEqual(['bar', 'baz'], err.files)
         self.assertEqual('Selected-file commit of merges is not supported'

=== modified file 'breezy/tests/test_controldir.py'
--- breezy/tests/test_controldir.py	2017-06-13 10:58:02 +0000
+++ breezy/tests/test_controldir.py	2017-07-24 01:10:54 +0000
@@ -31,6 +31,14 @@
 load_tests = load_tests_apply_scenarios
 
 
+class ErrorTests(tests.TestCase):
+
+    def test_must_have_working_tree(self):
+        err = controldir.MustHaveWorkingTree('foo', 'bar')
+        self.assertEqual(str(err), "Branching 'bar'(foo) must create a"
+                                   " working tree.")
+
+
 class SampleComponentFormat(controldir.ControlComponentFormat):
 
     def get_format_string(self):

=== modified file 'breezy/tests/test_directory_service.py'
--- breezy/tests/test_directory_service.py	2017-06-10 00:17:06 +0000
+++ breezy/tests/test_directory_service.py	2017-07-24 01:10:54 +0000
@@ -17,13 +17,14 @@
 """Test directory service implementation"""
 
 from .. import (
-    errors,
     transport,
     urlutils,
     )
 from ..directory_service import (
     AliasDirectory,
     DirectoryServiceRegistry,
+    InvalidLocationAlias,
+    UnsetLocationAlias,
     directories,
     )
 from . import TestCase, TestCaseWithTransport
@@ -101,13 +102,13 @@
                          directories.dereference(':this/arg'))
 
     def test_lookup_badname(self):
-        e = self.assertRaises(errors.InvalidLocationAlias,
+        e = self.assertRaises(InvalidLocationAlias,
                               directories.dereference, ':booga')
         self.assertEqual('":booga" is not a valid location alias.',
                          str(e))
 
     def test_lookup_badvalue(self):
-        e = self.assertRaises(errors.UnsetLocationAlias,
+        e = self.assertRaises(UnsetLocationAlias,
                               directories.dereference, ':parent')
         self.assertEqual('No parent location assigned.', str(e))
 

=== modified file 'breezy/tests/test_dirstate.py'
--- breezy/tests/test_dirstate.py	2017-06-11 01:22:16 +0000
+++ breezy/tests/test_dirstate.py	2017-07-24 01:10:54 +0000
@@ -54,6 +54,16 @@
 # set_path_id  setting id when state is in memory modified
 
 
+class ErrorTests(tests.TestCase):
+
+    def test_dirstate_corrupt(self):
+        error = dirstate.DirstateCorrupt('.bzr/checkout/dirstate',
+                                       'trailing garbage: "x"')
+        self.assertEqualDiff("The dirstate file (.bzr/checkout/dirstate)"
+            " appears to be corrupt: trailing garbage: \"x\"",
+            str(error))
+
+
 load_tests = load_tests_apply_scenarios
 
 

=== modified file 'breezy/tests/test_errors.py'
--- breezy/tests/test_errors.py	2017-07-24 01:07:36 +0000
+++ breezy/tests/test_errors.py	2017-07-24 01:10:54 +0000
@@ -63,20 +63,6 @@
             "^Filename b?'bad/filen\\\\xe5me' is not valid in your current"
             " filesystem encoding UTF-8$")
 
-    def test_corrupt_dirstate(self):
-        error = errors.CorruptDirstate('path/to/dirstate', 'the reason why')
-        self.assertEqualDiff(
-            "Inconsistency in dirstate file path/to/dirstate.\n"
-            "Error: the reason why",
-            str(error))
-
-    def test_dirstate_corrupt(self):
-        error = errors.DirstateCorrupt('.bzr/checkout/dirstate',
-                                       'trailing garbage: "x"')
-        self.assertEqualDiff("The dirstate file (.bzr/checkout/dirstate)"
-            " appears to be corrupt: trailing garbage: \"x\"",
-            str(error))
-
     def test_duplicate_file_id(self):
         error = errors.DuplicateFileId('a_file_id', 'foo')
         self.assertEqualDiff('File id {a_file_id} already exists in inventory'
@@ -239,25 +225,6 @@
             "('key',) which is encoded as 'fulltext'.",
             str(error))
 
-    def test_unknown_hook(self):
-        error = errors.UnknownHook("branch", "foo")
-        self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
-            " of breezy.",
-            str(error))
-        error = errors.UnknownHook("tree", "bar")
-        self.assertEqualDiff("The tree hook 'bar' is unknown in this version"
-            " of breezy.",
-            str(error))
-
-    def test_unstackable_branch_format(self):
-        format = u'foo'
-        url = "/foo"
-        error = errors.UnstackableBranchFormat(format, url)
-        self.assertEqualDiff(
-            "The branch '/foo'(foo) is not a stackable format. "
-            "You will need to upgrade the branch to permit branch stacking.",
-            str(error))
-
     def test_unstackable_location(self):
         error = errors.UnstackableLocationError('foo', 'bar')
         self.assertEqualDiff("The branch 'foo' cannot be stacked on 'bar'.",
@@ -501,10 +468,6 @@
         err = errors.UnknownFormatError('bar', kind='foo')
         self.assertEqual("Unknown foo format: 'bar'", str(err))
 
-    def test_unknown_rules(self):
-        err = errors.UnknownRules(['foo', 'bar'])
-        self.assertEqual("Unknown rules detected: foo, bar.", str(err))
-
     def test_tip_change_rejected(self):
         err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
         self.assertEqual(
@@ -538,11 +501,6 @@
         finally:
             del err
 
-    def test_must_have_working_tree(self):
-        err = errors.MustHaveWorkingTree('foo', 'bar')
-        self.assertEqual(str(err), "Branching 'bar'(foo) must create a"
-                                   " working tree.")
-
     def test_unresumable_write_group(self):
         repo = "dummy repo"
         wg_tokens = ['token']

=== modified file 'breezy/tests/test_hooks.py'
--- breezy/tests/test_hooks.py	2017-05-30 19:16:23 +0000
+++ breezy/tests/test_hooks.py	2017-07-24 01:10:54 +0000
@@ -26,12 +26,26 @@
 from ..hooks import (
     HookPoint,
     Hooks,
+    UnknownHook,
     install_lazy_named_hook,
     known_hooks,
     known_hooks_key_to_object,
     )
 
 
+class TestErrors(tests.TestCase):
+
+    def test_unknown_hook(self):
+        error = UnknownHook("branch", "foo")
+        self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
+            " of breezy.",
+            str(error))
+        error = UnknownHook("tree", "bar")
+        self.assertEqualDiff("The tree hook 'bar' is unknown in this version"
+            " of breezy.",
+            str(error))
+
+
 class TestHooks(tests.TestCase):
 
     def test_docs(self):
@@ -76,7 +90,7 @@
 
     def test_install_named_hook_raises_unknown_hook(self):
         hooks = Hooks("breezy.tests.test_hooks", "some_hooks")
-        self.assertRaises(errors.UnknownHook, hooks.install_named_hook, 'silly',
+        self.assertRaises(UnknownHook, hooks.install_named_hook, 'silly',
                           None, "")
 
     def test_install_named_hook_appends_known_hook(self):
@@ -118,8 +132,7 @@
 
     def test_uninstall_named_hook_raises_unknown_hook(self):
         hooks = Hooks("breezy.tests.test_hooks", "some_hooks")
-        self.assertRaises(errors.UnknownHook, hooks.uninstall_named_hook,
-            'silly', "")
+        self.assertRaises(UnknownHook, hooks.uninstall_named_hook, 'silly', "")
 
     def test_uninstall_named_hook_old_style(self):
         hooks = Hooks("breezy.tests.test_hooks", "some_hooks")

=== modified file 'breezy/tests/test_index.py'
--- breezy/tests/test_index.py	2017-06-08 23:30:31 +0000
+++ breezy/tests/test_index.py	2017-07-24 01:10:54 +0000
@@ -22,14 +22,14 @@
     transport,
     )
 from ..bzr import (
-    index,
+    index as _mod_index,
     )
 
 
 class TestGraphIndexBuilder(tests.TestCaseWithMemoryTransport):
 
     def test_build_index_empty(self):
-        builder = index.GraphIndexBuilder()
+        builder = _mod_index.GraphIndexBuilder()
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
@@ -37,7 +37,7 @@
             contents)
 
     def test_build_index_empty_two_element_keys(self):
-        builder = index.GraphIndexBuilder(key_elements=2)
+        builder = _mod_index.GraphIndexBuilder(key_elements=2)
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
@@ -45,7 +45,7 @@
             contents)
 
     def test_build_index_one_reference_list_empty(self):
-        builder = index.GraphIndexBuilder(reference_lists=1)
+        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
@@ -53,7 +53,7 @@
             contents)
 
     def test_build_index_two_reference_list_empty(self):
-        builder = index.GraphIndexBuilder(reference_lists=2)
+        builder = _mod_index.GraphIndexBuilder(reference_lists=2)
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
@@ -61,7 +61,7 @@
             contents)
 
     def test_build_index_one_node_no_refs(self):
-        builder = index.GraphIndexBuilder()
+        builder = _mod_index.GraphIndexBuilder()
         builder.add_node(('akey', ), 'data')
         stream = builder.finish()
         contents = stream.read()
@@ -70,7 +70,7 @@
             "akey\x00\x00\x00data\n\n", contents)
 
     def test_build_index_one_node_no_refs_accepts_empty_reflist(self):
-        builder = index.GraphIndexBuilder()
+        builder = _mod_index.GraphIndexBuilder()
         builder.add_node(('akey', ), 'data', ())
         stream = builder.finish()
         contents = stream.read()
@@ -82,7 +82,7 @@
         # multipart keys are separated by \x00 - because they are fixed length,
         # not variable this does not cause any issues, and seems clearer to the
         # author.
-        builder = index.GraphIndexBuilder(key_elements=2)
+        builder = _mod_index.GraphIndexBuilder(key_elements=2)
         builder.add_node(('akey', 'secondpart'), 'data')
         stream = builder.finish()
         contents = stream.read()
@@ -91,7 +91,7 @@
             "akey\x00secondpart\x00\x00\x00data\n\n", contents)
 
     def test_add_node_empty_value(self):
-        builder = index.GraphIndexBuilder()
+        builder = _mod_index.GraphIndexBuilder()
         builder.add_node(('akey', ), '')
         stream = builder.finish()
         contents = stream.read()
@@ -101,7 +101,7 @@
 
     def test_build_index_nodes_sorted(self):
         # the highest sorted node comes first.
-        builder = index.GraphIndexBuilder()
+        builder = _mod_index.GraphIndexBuilder()
         # use three to have a good chance of glitching dictionary hash
         # lookups etc. Insert in randomish order that is not correct
         # and not the reverse of the correct order.
@@ -119,7 +119,7 @@
 
     def test_build_index_2_element_key_nodes_sorted(self):
         # multiple element keys are sorted first-key, second-key.
-        builder = index.GraphIndexBuilder(key_elements=2)
+        builder = _mod_index.GraphIndexBuilder(key_elements=2)
         # use three values of each key element, to have a good chance of
         # glitching dictionary hash lookups etc. Insert in randomish order that
         # is not correct and not the reverse of the correct order.
@@ -148,7 +148,7 @@
             "\n", contents)
 
     def test_build_index_reference_lists_are_included_one(self):
-        builder = index.GraphIndexBuilder(reference_lists=1)
+        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
         builder.add_node(('key', ), 'data', ([], ))
         stream = builder.finish()
         contents = stream.read()
@@ -158,7 +158,7 @@
             "\n", contents)
 
     def test_build_index_reference_lists_with_2_element_keys(self):
-        builder = index.GraphIndexBuilder(reference_lists=1, key_elements=2)
+        builder = _mod_index.GraphIndexBuilder(reference_lists=1, key_elements=2)
         builder.add_node(('key', 'key2'), 'data', ([], ))
         stream = builder.finish()
         contents = stream.read()
@@ -168,7 +168,7 @@
             "\n", contents)
 
     def test_build_index_reference_lists_are_included_two(self):
-        builder = index.GraphIndexBuilder(reference_lists=2)
+        builder = _mod_index.GraphIndexBuilder(reference_lists=2)
         builder.add_node(('key', ), 'data', ([], []))
         stream = builder.finish()
         contents = stream.read()
@@ -178,12 +178,12 @@
             "\n", contents)
 
     def test_clear_cache(self):
-        builder = index.GraphIndexBuilder(reference_lists=2)
+        builder = _mod_index.GraphIndexBuilder(reference_lists=2)
         # This is a no-op, but the api should exist
         builder.clear_cache()
 
     def test_node_references_are_byte_offsets(self):
-        builder = index.GraphIndexBuilder(reference_lists=1)
+        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
         builder.add_node(('reference', ), 'data', ([], ))
         builder.add_node(('key', ), 'data', ([('reference', )], ))
         stream = builder.finish()
@@ -195,7 +195,7 @@
             "\n", contents)
 
     def test_node_references_are_cr_delimited(self):
-        builder = index.GraphIndexBuilder(reference_lists=1)
+        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
         builder.add_node(('reference', ), 'data', ([], ))
         builder.add_node(('reference2', ), 'data', ([], ))
         builder.add_node(('key', ), 'data',
@@ -210,7 +210,7 @@
             "\n", contents)
 
     def test_multiple_reference_lists_are_tab_delimited(self):
-        builder = index.GraphIndexBuilder(reference_lists=2)
+        builder = _mod_index.GraphIndexBuilder(reference_lists=2)
         builder.add_node(('keference', ), 'data', ([], []))
         builder.add_node(('rey', ), 'data',
                          ([('keference', )], [('keference', )]))
@@ -223,7 +223,7 @@
             "\n", contents)
 
     def test_add_node_referencing_missing_key_makes_absent(self):
-        builder = index.GraphIndexBuilder(reference_lists=1)
+        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
         builder.add_node(('rey', ), 'data',
                          ([('beference', ), ('aeference2', )], ))
         stream = builder.finish()
@@ -237,7 +237,7 @@
 
     def test_node_references_three_digits(self):
         # test the node digit expands as needed.
-        builder = index.GraphIndexBuilder(reference_lists=1)
+        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
         references = [(str(val), ) for val in range(8, -1, -1)]
         builder.add_node(('2-key', ), '', (references, ))
         stream = builder.finish()
@@ -259,7 +259,7 @@
     def test_absent_has_no_reference_overhead(self):
         # the offsets after an absent record should be correct when there are
         # >1 reference lists.
-        builder = index.GraphIndexBuilder(reference_lists=2)
+        builder = _mod_index.GraphIndexBuilder(reference_lists=2)
         builder.add_node(('parent', ), '', ([('aail', ), ('zther', )], []))
         stream = builder.finish()
         contents = stream.read()
@@ -271,99 +271,99 @@
             "\n", contents)
 
     def test_add_node_bad_key(self):
-        builder = index.GraphIndexBuilder()
+        builder = _mod_index.GraphIndexBuilder()
         for bad_char in '\t\n\x0b\x0c\r\x00 ':
-            self.assertRaises(errors.BadIndexKey, builder.add_node,
+            self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
                 ('a%skey' % bad_char, ), 'data')
-        self.assertRaises(errors.BadIndexKey, builder.add_node,
+        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
                 ('', ), 'data')
-        self.assertRaises(errors.BadIndexKey, builder.add_node,
+        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
                 'not-a-tuple', 'data')
         # not enough length
-        self.assertRaises(errors.BadIndexKey, builder.add_node,
+        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
                 (), 'data')
         # too long
-        self.assertRaises(errors.BadIndexKey, builder.add_node,
+        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
                 ('primary', 'secondary'), 'data')
         # secondary key elements get checked too:
-        builder = index.GraphIndexBuilder(key_elements=2)
+        builder = _mod_index.GraphIndexBuilder(key_elements=2)
         for bad_char in '\t\n\x0b\x0c\r\x00 ':
-            self.assertRaises(errors.BadIndexKey, builder.add_node,
+            self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
                 ('prefix', 'a%skey' % bad_char), 'data')
 
     def test_add_node_bad_data(self):
-        builder = index.GraphIndexBuilder()
-        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
+        builder = _mod_index.GraphIndexBuilder()
+        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
             'data\naa')
-        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
+        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
             'data\x00aa')
 
     def test_add_node_bad_mismatched_ref_lists_length(self):
-        builder = index.GraphIndexBuilder()
-        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
+        builder = _mod_index.GraphIndexBuilder()
+        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
             'data aa', ([], ))
-        builder = index.GraphIndexBuilder(reference_lists=1)
-        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
+        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
+        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
             'data aa')
-        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
+        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
             'data aa', (), )
-        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
+        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
             'data aa', ([], []))
-        builder = index.GraphIndexBuilder(reference_lists=2)
-        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
+        builder = _mod_index.GraphIndexBuilder(reference_lists=2)
+        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
             'data aa')
-        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
+        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
             'data aa', ([], ))
-        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
+        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
             'data aa', ([], [], []))
 
     def test_add_node_bad_key_in_reference_lists(self):
         # first list, first key - trivial
-        builder = index.GraphIndexBuilder(reference_lists=1)
-        self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
+        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
+        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, ('akey', ),
             'data aa', ([('a key', )], ))
         # references keys must be tuples too
-        self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
+        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, ('akey', ),
             'data aa', (['not-a-tuple'], ))
         # not enough length
-        self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
+        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, ('akey', ),
             'data aa', ([()], ))
         # too long
-        self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
+        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, ('akey', ),
             'data aa', ([('primary', 'secondary')], ))
         # need to check more than the first key in the list
-        self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
+        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, ('akey', ),
             'data aa', ([('agoodkey', ), ('that is a bad key', )], ))
         # and if there is more than one list it should be getting checked
         # too
-        builder = index.GraphIndexBuilder(reference_lists=2)
-        self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
+        builder = _mod_index.GraphIndexBuilder(reference_lists=2)
+        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, ('akey', ),
             'data aa', ([], ['a bad key']))
 
     def test_add_duplicate_key(self):
-        builder = index.GraphIndexBuilder()
+        builder = _mod_index.GraphIndexBuilder()
         builder.add_node(('key', ), 'data')
-        self.assertRaises(errors.BadIndexDuplicateKey,
+        self.assertRaises(_mod_index.BadIndexDuplicateKey,
                           builder.add_node, ('key', ), 'data')
 
     def test_add_duplicate_key_2_elements(self):
-        builder = index.GraphIndexBuilder(key_elements=2)
+        builder = _mod_index.GraphIndexBuilder(key_elements=2)
         builder.add_node(('key', 'key'), 'data')
-        self.assertRaises(errors.BadIndexDuplicateKey, builder.add_node,
+        self.assertRaises(_mod_index.BadIndexDuplicateKey, builder.add_node,
             ('key', 'key'), 'data')
 
     def test_add_key_after_referencing_key(self):
-        builder = index.GraphIndexBuilder(reference_lists=1)
+        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
         builder.add_node(('key', ), 'data', ([('reference', )], ))
         builder.add_node(('reference', ), 'data', ([],))
 
     def test_add_key_after_referencing_key_2_elements(self):
-        builder = index.GraphIndexBuilder(reference_lists=1, key_elements=2)
+        builder = _mod_index.GraphIndexBuilder(reference_lists=1, key_elements=2)
         builder.add_node(('k', 'ey'), 'data', ([('reference', 'tokey')], ))
         builder.add_node(('reference', 'tokey'), 'data', ([],))
 
     def test_set_optimize(self):
-        builder = index.GraphIndexBuilder(reference_lists=1, key_elements=2)
+        builder = _mod_index.GraphIndexBuilder(reference_lists=1, key_elements=2)
         builder.set_optimize(for_size=True)
         self.assertTrue(builder._optimize_for_size)
         builder.set_optimize(for_size=False)
@@ -387,24 +387,24 @@
         return nodes
 
     def make_index(self, ref_lists=0, key_elements=1, nodes=[]):
-        builder = index.GraphIndexBuilder(ref_lists, key_elements=key_elements)
+        builder = _mod_index.GraphIndexBuilder(ref_lists, key_elements=key_elements)
         for key, value, references in nodes:
             builder.add_node(key, value, references)
         stream = builder.finish()
         trans = transport.get_transport_from_url('trace+' + self.get_url())
         size = trans.put_file('index', stream)
-        return index.GraphIndex(trans, 'index', size)
+        return _mod_index.GraphIndex(trans, 'index', size)
 
     def make_index_with_offset(self, ref_lists=0, key_elements=1, nodes=[],
                                offset=0):
-        builder = index.GraphIndexBuilder(ref_lists, key_elements=key_elements)
+        builder = _mod_index.GraphIndexBuilder(ref_lists, key_elements=key_elements)
         for key, value, references in nodes:
             builder.add_node(key, value, references)
         content = builder.finish().read()
         size = len(content)
         trans = self.get_transport()
         trans.put_bytes('index', (' '*offset) + content)
-        return index.GraphIndex(trans, 'index', size, offset=offset)
+        return _mod_index.GraphIndex(trans, 'index', size, offset=offset)
 
     def test_clear_cache(self):
         index = self.make_index()
@@ -415,7 +415,7 @@
     def test_open_bad_index_no_error(self):
         trans = self.get_transport()
         trans.put_bytes('name', "not an index\n")
-        idx = index.GraphIndex(trans, 'name', 13)
+        idx = _mod_index.GraphIndex(trans, 'name', 13)
 
     def test_with_offset(self):
         nodes = self.make_nodes(200)
@@ -838,22 +838,22 @@
 
     def test_iter_missing_entry_empty_no_size(self):
         idx = self.make_index()
-        idx = index.GraphIndex(idx._transport, 'index', None)
+        idx = _mod_index.GraphIndex(idx._transport, 'index', None)
         self.assertEqual([], list(idx.iter_entries([('a', )])))
 
     def test_iter_key_prefix_1_element_key_None(self):
         index = self.make_index()
-        self.assertRaises(errors.BadIndexKey, list,
+        self.assertRaises(_mod_index.BadIndexKey, list,
             index.iter_entries_prefix([(None, )]))
 
     def test_iter_key_prefix_wrong_length(self):
         index = self.make_index()
-        self.assertRaises(errors.BadIndexKey, list,
+        self.assertRaises(_mod_index.BadIndexKey, list,
             index.iter_entries_prefix([('foo', None)]))
         index = self.make_index(key_elements=2)
-        self.assertRaises(errors.BadIndexKey, list,
+        self.assertRaises(_mod_index.BadIndexKey, list,
             index.iter_entries_prefix([('foo', )]))
-        self.assertRaises(errors.BadIndexKey, list,
+        self.assertRaises(_mod_index.BadIndexKey, list,
             index.iter_entries_prefix([('foo', None, None)]))
 
     def test_iter_key_prefix_1_key_element_no_refs(self):
@@ -935,8 +935,8 @@
     def test_validate_bad_index_errors(self):
         trans = self.get_transport()
         trans.put_bytes('name', "not an index\n")
-        idx = index.GraphIndex(trans, 'name', 13)
-        self.assertRaises(errors.BadIndexFormatSignature, idx.validate)
+        idx = _mod_index.GraphIndex(trans, 'name', 13)
+        self.assertRaises(_mod_index.BadIndexFormatSignature, idx.validate)
 
     def test_validate_bad_node_refs(self):
         idx = self.make_index(2)
@@ -945,7 +945,7 @@
         # change the options line to end with a rather than a parseable number
         new_content = content[:-2] + 'a\n\n'
         trans.put_bytes('index', new_content)
-        self.assertRaises(errors.BadIndexOptions, idx.validate)
+        self.assertRaises(_mod_index.BadIndexOptions, idx.validate)
 
     def test_validate_missing_end_line_empty(self):
         index = self.make_index(2)
@@ -953,7 +953,7 @@
         content = trans.get_bytes('index')
         # truncate the last byte
         trans.put_bytes('index', content[:-1])
-        self.assertRaises(errors.BadIndexData, index.validate)
+        self.assertRaises(_mod_index.BadIndexData, index.validate)
 
     def test_validate_missing_end_line_nonempty(self):
         index = self.make_index(2, nodes=[(('key', ), '', ([], []))])
@@ -961,7 +961,7 @@
         content = trans.get_bytes('index')
         # truncate the last byte
         trans.put_bytes('index', content[:-1])
-        self.assertRaises(errors.BadIndexData, index.validate)
+        self.assertRaises(_mod_index.BadIndexData, index.validate)
 
     def test_validate_empty(self):
         index = self.make_index()
@@ -1056,25 +1056,25 @@
         self.assertEqual(set(), search_keys)
 
     def test_supports_unlimited_cache(self):
-        builder = index.GraphIndexBuilder(0, key_elements=1)
+        builder = _mod_index.GraphIndexBuilder(0, key_elements=1)
         stream = builder.finish()
         trans = self.get_transport()
         size = trans.put_file('index', stream)
         # It doesn't matter what unlimited_cache does here, just that it can be
         # passed
-        idx = index.GraphIndex(trans, 'index', size, unlimited_cache=True)
+        idx = _mod_index.GraphIndex(trans, 'index', size, unlimited_cache=True)
 
 
 class TestCombinedGraphIndex(tests.TestCaseWithMemoryTransport):
 
     def make_index(self, name, ref_lists=0, key_elements=1, nodes=[]):
-        builder = index.GraphIndexBuilder(ref_lists, key_elements=key_elements)
+        builder = _mod_index.GraphIndexBuilder(ref_lists, key_elements=key_elements)
         for key, value, references in nodes:
             builder.add_node(key, value, references)
         stream = builder.finish()
         trans = self.get_transport()
         size = trans.put_file(name, stream)
-        return index.GraphIndex(trans, name, size)
+        return _mod_index.GraphIndex(trans, name, size)
 
     def make_combined_index_with_missing(self, missing=['1', '2']):
         """Create a CombinedGraphIndex which will have missing indexes.
@@ -1103,7 +1103,7 @@
             reload_counter[1] += 1
             idx._indices[:] = new_indices
             return True
-        idx = index.CombinedGraphIndex([idx1, idx2], reload_func=reload)
+        idx = _mod_index.CombinedGraphIndex([idx1, idx2], reload_func=reload)
         trans = self.get_transport()
         for fname in missing:
             trans.delete(fname)
@@ -1111,11 +1111,11 @@
 
     def test_open_missing_index_no_error(self):
         trans = self.get_transport()
-        idx1 = index.GraphIndex(trans, 'missing', 100)
-        idx = index.CombinedGraphIndex([idx1])
+        idx1 = _mod_index.GraphIndex(trans, 'missing', 100)
+        idx = _mod_index.CombinedGraphIndex([idx1])
 
     def test_add_index(self):
-        idx = index.CombinedGraphIndex([])
+        idx = _mod_index.CombinedGraphIndex([])
         idx1 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
         idx.insert_index(0, idx1)
         self.assertEqual([(idx1, ('key', ), '')],
@@ -1136,7 +1136,7 @@
                 log.append(self._index)
                 return self._index.clear_cache()
 
-        idx = index.CombinedGraphIndex([])
+        idx = _mod_index.CombinedGraphIndex([])
         idx1 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
         idx.insert_index(0, ClearCacheProxy(idx1))
         idx2 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
@@ -1146,24 +1146,24 @@
         self.assertEqual(sorted([idx1, idx2]), sorted(log))
 
     def test_iter_all_entries_empty(self):
-        idx = index.CombinedGraphIndex([])
+        idx = _mod_index.CombinedGraphIndex([])
         self.assertEqual([], list(idx.iter_all_entries()))
 
     def test_iter_all_entries_children_empty(self):
         idx1 = self.make_index('name')
-        idx = index.CombinedGraphIndex([idx1])
+        idx = _mod_index.CombinedGraphIndex([idx1])
         self.assertEqual([], list(idx.iter_all_entries()))
 
     def test_iter_all_entries_simple(self):
         idx1 = self.make_index('name', nodes=[(('name', ), 'data', ())])
-        idx = index.CombinedGraphIndex([idx1])
+        idx = _mod_index.CombinedGraphIndex([idx1])
         self.assertEqual([(idx1, ('name', ), 'data')],
             list(idx.iter_all_entries()))
 
     def test_iter_all_entries_two_indices(self):
         idx1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
         idx2 = self.make_index('name2', nodes=[(('2', ), '', ())])
-        idx = index.CombinedGraphIndex([idx1, idx2])
+        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
         self.assertEqual([(idx1, ('name', ), 'data'),
                           (idx2, ('2', ), '')],
                          list(idx.iter_all_entries()))
@@ -1171,14 +1171,14 @@
     def test_iter_entries_two_indices_dup_key(self):
         idx1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
         idx2 = self.make_index('name2', nodes=[(('name', ), 'data', ())])
-        idx = index.CombinedGraphIndex([idx1, idx2])
+        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
         self.assertEqual([(idx1, ('name', ), 'data')],
                          list(idx.iter_entries([('name', )])))
 
     def test_iter_all_entries_two_indices_dup_key(self):
         idx1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
         idx2 = self.make_index('name2', nodes=[(('name', ), 'data', ())])
-        idx = index.CombinedGraphIndex([idx1, idx2])
+        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
         self.assertEqual([(idx1, ('name', ), 'data')],
                          list(idx.iter_all_entries()))
 
@@ -1188,7 +1188,7 @@
         idx2 = self.make_index('2', 1, key_elements=2, nodes=[
                 (('name', 'fin2'), 'beta', ([], )),
                 (('ref', 'erence'), 'refdata', ([], ))])
-        idx = index.CombinedGraphIndex([idx1, idx2])
+        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
         self.assertEqual({(idx1, ('name', 'fin1'), 'data',
                                ((('ref', 'erence'),),)),
                               (idx2, ('ref', 'erence'), 'refdata', ((), ))},
@@ -1200,19 +1200,19 @@
                          set(idx.iter_entries_prefix([('name', None)])))
 
     def test_iter_nothing_empty(self):
-        idx = index.CombinedGraphIndex([])
+        idx = _mod_index.CombinedGraphIndex([])
         self.assertEqual([], list(idx.iter_entries([])))
 
     def test_iter_nothing_children_empty(self):
         idx1 = self.make_index('name')
-        idx = index.CombinedGraphIndex([idx1])
+        idx = _mod_index.CombinedGraphIndex([idx1])
         self.assertEqual([], list(idx.iter_entries([])))
 
     def test_iter_all_keys(self):
         idx1 = self.make_index('1', 1, nodes=[(('name', ), 'data',
                                                ([('ref', )], ))])
         idx2 = self.make_index('2', 1, nodes=[(('ref', ), 'refdata', ((), ))])
-        idx = index.CombinedGraphIndex([idx1, idx2])
+        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
         self.assertEqual({(idx1, ('name', ), 'data', ((('ref', ), ), )),
                               (idx2, ('ref', ), 'refdata', ((), ))},
                          set(idx.iter_entries([('name', ), ('ref', )])))
@@ -1222,41 +1222,41 @@
                                                  ([('ref', )], )),
                                                 (('ref', ), 'refdata', ([], ))])
         idx2 = self.make_index('2', 1, nodes=[(('ref', ), 'refdata', ([], ))])
-        idx = index.CombinedGraphIndex([idx1, idx2])
+        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
         self.assertEqual({(idx1, ('name', ), 'data', ((('ref',),),)),
                               (idx1, ('ref', ), 'refdata', ((), ))},
                          set(idx.iter_entries([('name', ), ('ref', )])))
 
     def test_iter_missing_entry_empty(self):
-        idx = index.CombinedGraphIndex([])
+        idx = _mod_index.CombinedGraphIndex([])
         self.assertEqual([], list(idx.iter_entries([('a', )])))
 
     def test_iter_missing_entry_one_index(self):
         idx1 = self.make_index('1')
-        idx = index.CombinedGraphIndex([idx1])
+        idx = _mod_index.CombinedGraphIndex([idx1])
         self.assertEqual([], list(idx.iter_entries([('a', )])))
 
     def test_iter_missing_entry_two_index(self):
         idx1 = self.make_index('1')
         idx2 = self.make_index('2')
-        idx = index.CombinedGraphIndex([idx1, idx2])
+        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
         self.assertEqual([], list(idx.iter_entries([('a', )])))
 
     def test_iter_entry_present_one_index_only(self):
         idx1 = self.make_index('1', nodes=[(('key', ), '', ())])
         idx2 = self.make_index('2', nodes=[])
-        idx = index.CombinedGraphIndex([idx1, idx2])
+        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
         self.assertEqual([(idx1, ('key', ), '')],
                          list(idx.iter_entries([('key', )])))
         # and in the other direction
-        idx = index.CombinedGraphIndex([idx2, idx1])
+        idx = _mod_index.CombinedGraphIndex([idx2, idx1])
         self.assertEqual([(idx1, ('key', ), '')],
                          list(idx.iter_entries([('key', )])))
 
     def test_key_count_empty(self):
         idx1 = self.make_index('1', nodes=[])
         idx2 = self.make_index('2', nodes=[])
-        idx = index.CombinedGraphIndex([idx1, idx2])
+        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
         self.assertEqual(0, idx.key_count())
 
     def test_key_count_sums_index_keys(self):
@@ -1264,18 +1264,18 @@
             (('1',), '', ()),
             (('2',), '', ())])
         idx2 = self.make_index('2', nodes=[(('1',), '', ())])
-        idx = index.CombinedGraphIndex([idx1, idx2])
+        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
         self.assertEqual(3, idx.key_count())
 
     def test_validate_bad_child_index_errors(self):
         trans = self.get_transport()
         trans.put_bytes('name', "not an index\n")
-        idx1 = index.GraphIndex(trans, 'name', 13)
-        idx = index.CombinedGraphIndex([idx1])
-        self.assertRaises(errors.BadIndexFormatSignature, idx.validate)
+        idx1 = _mod_index.GraphIndex(trans, 'name', 13)
+        idx = _mod_index.CombinedGraphIndex([idx1])
+        self.assertRaises(_mod_index.BadIndexFormatSignature, idx.validate)
 
     def test_validate_empty(self):
-        idx = index.CombinedGraphIndex([])
+        idx = _mod_index.CombinedGraphIndex([])
         idx.validate()
 
     def test_key_count_reloads(self):
@@ -1403,7 +1403,7 @@
     def test_reorder_after_iter_entries(self):
         # Four indices: [key1] in idx1, [key2,key3] in idx2, [] in idx3,
         # [key4] in idx4.
-        idx = index.CombinedGraphIndex([])
+        idx = _mod_index.CombinedGraphIndex([])
         idx.insert_index(0, self.make_index_with_simple_nodes('1'), '1')
         idx.insert_index(1, self.make_index_with_simple_nodes('2'), '2')
         idx.insert_index(2, self.make_index_with_simple_nodes('3'), '3')
@@ -1420,8 +1420,8 @@
     def test_reorder_propagates_to_siblings(self):
         # Two CombinedGraphIndex objects, with the same number of indicies with
         # matching names.
-        cgi1 = index.CombinedGraphIndex([])
-        cgi2 = index.CombinedGraphIndex([])
+        cgi1 = _mod_index.CombinedGraphIndex([])
+        cgi2 = _mod_index.CombinedGraphIndex([])
         cgi1.insert_index(0, self.make_index_with_simple_nodes('1-1'), 'one')
         cgi1.insert_index(1, self.make_index_with_simple_nodes('1-2'), 'two')
         cgi2.insert_index(0, self.make_index_with_simple_nodes('2-1'), 'one')
@@ -1465,7 +1465,7 @@
             (key3, 'value', ([key2],)),
             (key4, 'value', ([key3],)),
             ])
-        c_index = index.CombinedGraphIndex([index1, index2])
+        c_index = _mod_index.CombinedGraphIndex([index1, index2])
         parent_map, missing_keys = c_index.find_ancestry([key1], 0)
         self.assertEqual({key1: ()}, parent_map)
         self.assertEqual(set(), missing_keys)
@@ -1488,7 +1488,7 @@
         index2 = self.make_index('34', ref_lists=1, nodes=[
             (key3, 'value', ([key2],)),
             ])
-        c_index = index.CombinedGraphIndex([index1, index2])
+        c_index = _mod_index.CombinedGraphIndex([index1, index2])
         # Searching for a key which is actually not present at all should
         # eventually converge
         parent_map, missing_keys = c_index.find_ancestry([key4], 0)
@@ -1496,7 +1496,7 @@
         self.assertEqual({key4}, missing_keys)
 
     def test_find_ancestors_no_indexes(self):
-        c_index = index.CombinedGraphIndex([])
+        c_index = _mod_index.CombinedGraphIndex([])
         key1 = ('key-1',)
         parent_map, missing_keys = c_index.find_ancestry([key1], 0)
         self.assertEqual({}, parent_map)
@@ -1514,7 +1514,7 @@
         index2 = self.make_index('34', ref_lists=1, nodes=[
             (key4, 'value', ([key2, key3],)),
             ])
-        c_index = index.CombinedGraphIndex([index1, index2])
+        c_index = _mod_index.CombinedGraphIndex([index1, index2])
         # Searching for a key which is actually not present at all should
         # eventually converge
         parent_map, missing_keys = c_index.find_ancestry([key4], 0)
@@ -1536,7 +1536,7 @@
 class TestInMemoryGraphIndex(tests.TestCaseWithMemoryTransport):
 
     def make_index(self, ref_lists=0, key_elements=1, nodes=[]):
-        result = index.InMemoryGraphIndex(ref_lists, key_elements=key_elements)
+        result = _mod_index.InMemoryGraphIndex(ref_lists, key_elements=key_elements)
         result.add_nodes(nodes)
         return result
 
@@ -1667,13 +1667,13 @@
 
     def make_index(self, ref_lists=1, key_elements=2, nodes=[],
                    add_callback=False):
-        result = index.InMemoryGraphIndex(ref_lists, key_elements=key_elements)
+        result = _mod_index.InMemoryGraphIndex(ref_lists, key_elements=key_elements)
         result.add_nodes(nodes)
         if add_callback:
             add_nodes_callback = result.add_nodes
         else:
             add_nodes_callback = None
-        adapter = index.GraphIndexPrefixAdapter(
+        adapter = _mod_index.GraphIndexPrefixAdapter(
             result, ('prefix', ), key_elements - 1,
             add_nodes_callback=add_nodes_callback)
         return result, adapter
@@ -1698,18 +1698,18 @@
             set(index.iter_all_entries()))
 
     def test_construct(self):
-        idx = index.InMemoryGraphIndex()
-        adapter = index.GraphIndexPrefixAdapter(idx, ('prefix', ), 1)
+        idx = _mod_index.InMemoryGraphIndex()
+        adapter = _mod_index.GraphIndexPrefixAdapter(idx, ('prefix', ), 1)
 
     def test_construct_with_callback(self):
-        idx = index.InMemoryGraphIndex()
-        adapter = index.GraphIndexPrefixAdapter(idx, ('prefix', ), 1,
+        idx = _mod_index.InMemoryGraphIndex()
+        adapter = _mod_index.GraphIndexPrefixAdapter(idx, ('prefix', ), 1,
                                                 idx.add_nodes)
 
     def test_iter_all_entries_cross_prefix_map_errors(self):
         index, adapter = self.make_index(nodes=[
             (('prefix', 'key1'), 'data1', ((('prefixaltered', 'key2'),),))])
-        self.assertRaises(errors.BadIndexData, list, adapter.iter_all_entries())
+        self.assertRaises(_mod_index.BadIndexData, list, adapter.iter_all_entries())
 
     def test_iter_all_entries(self):
         index, adapter = self.make_index(nodes=[

=== modified file 'breezy/tests/test_msgeditor.py'
--- breezy/tests/test_msgeditor.py	2017-06-10 00:17:06 +0000
+++ breezy/tests/test_msgeditor.py	2017-07-24 01:10:54 +0000
@@ -339,7 +339,7 @@
         self.make_fake_editor(message=char)
 
         working_tree = self.make_uncommitted_tree()
-        self.assertRaises(errors.BadCommitMessageEncoding,
+        self.assertRaises(msgeditor.BadCommitMessageEncoding,
                           msgeditor.edit_commit_message, '')
 
     def test_set_commit_message_no_hooks(self):

=== modified file 'breezy/tests/test_osutils.py'
--- breezy/tests/test_osutils.py	2017-06-15 00:39:26 +0000
+++ breezy/tests/test_osutils.py	2017-07-24 01:10:54 +0000
@@ -404,7 +404,7 @@
         self.assertFormatedDelta('2 seconds in the future', -2)
 
     def test_format_date(self):
-        self.assertRaises(errors.UnsupportedTimezoneFormat,
+        self.assertRaises(osutils.UnsupportedTimezoneFormat,
             osutils.format_date, 0, timezone='foo')
         self.assertIsInstance(osutils.format_date(0), str)
         self.assertIsInstance(osutils.format_local_date(0), unicode)

=== modified file 'breezy/tests/test_reconfigure.py'
--- breezy/tests/test_reconfigure.py	2017-06-10 16:40:42 +0000
+++ breezy/tests/test_reconfigure.py	2017-07-24 01:10:54 +0000
@@ -62,7 +62,7 @@
 
     def test_branch_to_branch(self):
         branch = self.make_branch('branch')
-        self.assertRaises(errors.AlreadyBranch,
+        self.assertRaises(reconfigure.AlreadyBranch,
                           reconfigure.Reconfigure.to_branch, branch.controldir)
 
     def test_repo_to_branch(self):
@@ -142,13 +142,13 @@
 
     def test_tree_to_tree(self):
         tree = self.make_branch_and_tree('tree')
-        self.assertRaises(errors.AlreadyTree, reconfigure.Reconfigure.to_tree,
-                          tree.controldir)
+        self.assertRaises(reconfigure.AlreadyTree,
+                          reconfigure.Reconfigure.to_tree, tree.controldir)
 
     def test_select_bind_location(self):
         branch = self.make_branch('branch')
         reconfiguration = reconfigure.Reconfigure(branch.controldir)
-        self.assertRaises(errors.NoBindLocation,
+        self.assertRaises(reconfigure.NoBindLocation,
                           reconfiguration._select_bind_location)
         branch.set_parent('http://parent')
         reconfiguration = reconfigure.Reconfigure(branch.controldir)
@@ -189,7 +189,7 @@
 
         tree = self.make_branch_and_tree('tree')
         reconfiguration = reconfigure.Reconfigure.to_checkout(tree.controldir)
-        self.assertRaises(errors.NoBindLocation, reconfiguration.apply)
+        self.assertRaises(reconfigure.NoBindLocation, reconfiguration.apply)
         # setting a parent allows it to become a checkout
         tree.branch.set_parent(parent.base)
         reconfiguration = reconfigure.Reconfigure.to_checkout(tree.controldir)
@@ -208,7 +208,7 @@
         tree = self.make_branch_and_tree('tree')
         reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
             tree.controldir)
-        self.assertRaises(errors.NoBindLocation, reconfiguration.apply)
+        self.assertRaises(reconfigure.NoBindLocation, reconfiguration.apply)
         # setting a parent allows it to become a checkout
         tree.branch.set_parent(parent.base)
         reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
@@ -223,7 +223,7 @@
     def test_checkout_to_checkout(self):
         parent = self.make_branch('parent')
         checkout = parent.create_checkout('checkout')
-        self.assertRaises(errors.AlreadyCheckout,
+        self.assertRaises(reconfigure.AlreadyCheckout,
                           reconfigure.Reconfigure.to_checkout, checkout.controldir)
 
     def make_unsynced_checkout(self):
@@ -236,7 +236,7 @@
 
     def test_unsynced_checkout_to_lightweight(self):
         checkout, parent, reconfiguration = self.make_unsynced_checkout()
-        self.assertRaises(errors.UnsyncedBranches, reconfiguration.apply)
+        self.assertRaises(reconfigure.UnsyncedBranches, reconfiguration.apply)
 
     def test_synced_checkout_to_lightweight(self):
         checkout, parent, reconfiguration = self.make_unsynced_checkout()
@@ -294,7 +294,7 @@
     def test_lightweight_checkout_to_lightweight_checkout(self):
         parent = self.make_branch('parent')
         checkout = parent.create_checkout('checkout', lightweight=True)
-        self.assertRaises(errors.AlreadyLightweightCheckout,
+        self.assertRaises(reconfigure.AlreadyLightweightCheckout,
                           reconfigure.Reconfigure.to_lightweight_checkout,
                           checkout.controldir)
 
@@ -308,7 +308,7 @@
         repo = self.make_repository('repo', shared=True)
         reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
             repo.controldir)
-        self.assertRaises(errors.NoBindLocation, reconfiguration.apply)
+        self.assertRaises(reconfigure.NoBindLocation, reconfiguration.apply)
         branch = self.make_branch('branch')
         reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
             repo.controldir, 'branch')
@@ -364,7 +364,7 @@
 
     def test_use_shared_to_use_shared(self):
         tree = self.make_repository_tree()
-        self.assertRaises(errors.AlreadyUsingShared,
+        self.assertRaises(reconfigure.AlreadyUsingShared,
                           reconfigure.Reconfigure.to_use_shared, tree.controldir)
 
     def test_use_shared_to_standalone(self):
@@ -389,7 +389,7 @@
 
     def test_standalone_to_standalone(self):
         tree = self.make_branch_and_tree('tree')
-        self.assertRaises(errors.AlreadyStandalone,
+        self.assertRaises(reconfigure.AlreadyStandalone,
                           reconfigure.Reconfigure.to_standalone, tree.controldir)
 
     def make_unsynced_branch_reconfiguration(self):
@@ -401,7 +401,7 @@
 
     def test_unsynced_branch_to_lightweight_checkout_unforced(self):
         reconfiguration = self.make_unsynced_branch_reconfiguration()
-        self.assertRaises(errors.UnsyncedBranches, reconfiguration.apply)
+        self.assertRaises(reconfigure.UnsyncedBranches, reconfiguration.apply)
 
     def test_unsynced_branch_to_lightweight_checkout_forced(self):
         reconfiguration = self.make_unsynced_branch_reconfiguration()
@@ -428,21 +428,21 @@
 
     def test_make_with_trees_already_with_trees(self):
         repo = self.make_repository_with_without_trees(True)
-        e = self.assertRaises(errors.AlreadyWithTrees,
+        e = self.assertRaises(reconfiure.AlreadyWithTrees,
            reconfigure.Reconfigure.set_repository_trees, repo.controldir, True)
         self.assertContainsRe(str(e),
             r"Shared repository '.*' already creates working trees.")
 
     def test_make_without_trees_already_no_trees(self):
         repo = self.make_repository_with_without_trees(False)
-        e = self.assertRaises(errors.AlreadyWithNoTrees,
+        e = self.assertRaises(reconfigure.AlreadyWithNoTrees,
             reconfigure.Reconfigure.set_repository_trees, repo.controldir, False)
         self.assertContainsRe(str(e),
             r"Shared repository '.*' already doesn't create working trees.")
 
     def test_repository_tree_reconfiguration_not_supported(self):
         tree = self.make_branch_and_tree('tree')
-        e = self.assertRaises(errors.ReconfigurationNotSupported,
+        e = self.assertRaises(reconfigure.ReconfigurationNotSupported,
             reconfigure.Reconfigure.set_repository_trees, tree.controldir, None)
         self.assertContainsRe(str(e),
             r"Requested reconfiguration of '.*' is not supported.")

=== modified file 'breezy/tests/test_rules.py'
--- breezy/tests/test_rules.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/test_rules.py	2017-07-24 01:10:54 +0000
@@ -19,12 +19,18 @@
 import sys
 
 from breezy import (
-    errors,
     rules,
     tests,
     )
 
 
+class ErrorTests(tests.TestCase):
+
+    def test_unknown_rules(self):
+        err = rules.UnknownRules(['foo', 'bar'])
+        self.assertEqual("Unknown rules detected: foo, bar.", str(err))
+
+
 class TestIniBasedRulesSearcher(tests.TestCase):
 
     def make_searcher(self, text):
@@ -36,8 +42,8 @@
         return rules._IniBasedRulesSearcher(lines)
 
     def test_unknown_namespace(self):
-        self.assertRaises(errors.UnknownRules, rules._IniBasedRulesSearcher,
-            ["[junk]", "foo=bar"])
+        self.assertRaises(rules.UnknownRules, rules._IniBasedRulesSearcher,
+                          ["[junk]", "foo=bar"])
 
     def test_get_items_file_missing(self):
         rs = self.make_searcher(None)

=== modified file 'breezy/tests/test_version_info.py'
--- breezy/tests/test_version_info.py	2017-06-10 00:17:06 +0000
+++ breezy/tests/test_version_info.py	2017-07-24 01:10:54 +0000
@@ -21,7 +21,6 @@
 import sys
 
 from .. import (
-    errors,
     registry,
     tests,
     version_info_formats,
@@ -32,7 +31,11 @@
 from . import TestCaseWithTransport
 from ..rio import read_stanzas
 
-from ..version_info_formats.format_custom import CustomVersionInfoBuilder
+from ..version_info_formats.format_custom import (
+    CustomVersionInfoBuilder,
+    MissingTemplateVariable,
+    NoTemplate,
+    )
 from ..version_info_formats.format_rio import RioVersionInfoBuilder
 from ..version_info_formats.format_python import PythonVersionInfoBuilder
 
@@ -346,8 +349,7 @@
         builder = CustomVersionInfoBuilder(wt.branch, working_tree=wt, 
             template='{revno} revid: {revision_id}')
         # revision_id is not available yet
-        self.assertRaises(errors.MissingTemplateVariable, 
-            builder.generate, sio)
+        self.assertRaises(MissingTemplateVariable, builder.generate, sio)
 
     def test_custom_dotted_revno(self):
         sio = BytesIO()
@@ -398,7 +400,7 @@
     def test_custom_without_template(self):
         builder = CustomVersionInfoBuilder(None)
         sio = BytesIO()
-        self.assertRaises(errors.NoTemplate, builder.generate, sio)
+        self.assertRaises(NoTemplate, builder.generate, sio)
 
 
 class TestBuilder(version_info_formats.VersionInfoBuilder):

=== modified file 'breezy/version_info_formats/format_custom.py'
--- breezy/version_info_formats/format_custom.py	2017-06-14 23:29:06 +0000
+++ breezy/version_info_formats/format_custom.py	2017-07-24 01:10:54 +0000
@@ -30,6 +30,19 @@
    )
 
 
+class MissingTemplateVariable(errors.BzrError):
+
+    _fmt = 'Variable {%(name)s} is not available.'
+
+    def __init__(self, name):
+        self.name = name
+
+
+class NoTemplate(errors.BzrError):
+
+    _fmt = 'No template specified.'
+
+
 class Template(object):
     """A simple template engine.