Bazaar

Merge lp:~jelmer/bzr/foreign-tests into lp:~bzr/bzr/trunk-old

foreign-tests
Merge into trunk-old

Proposed by Jelmer Vernooij on 2009-08-04

Status:	Rejected
Rejected by:	Ian Clatworthy on 2009-10-14
Proposed branch:	lp:~jelmer/bzr/foreign-tests
Merge into:	lp:~bzr/bzr/trunk-old
Diff against target:	151 lines
To merge this branch:	bzr merge lp:~jelmer/bzr/foreign-tests
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
John A Meinel		2009-08-04	Needs Fixing on 2009-08-13
Review via email: mp+9642@code.launchpad.net

Revision history for this message

Jelmer Vernooij (jelmer) wrote on 2009-08-04:

This branch adds two testcase classes in bzrlib.tests.foreign.test_branch that can be used as basis for the testcases in foreign branch plugins. I've posted matching branches of bzr-svn (lp:~jelmer/bzr-svn/foreign-tests and bzr-git (lp:~jelmer/bzr-git/foreign-tests) that use this. I'm hoping to add a lot more (and more complex) generic tests for the foreign code, to avoid duplicate work in each foreign vcs plugin.

I've considered using adapters rather than "manual" subclassing, but since some subclassing will be needed anyway (the generic tests don't test everything that should be tested) I think that would be overkill.

Does this seem like a reasonable approach?

Revision history for this message

John A Meinel (jameinel) wrote on 2009-08-13:

If we are going to go this route, I would probably call it a ForeignBranchTestMixin

since it is meant as a second parent class. (eg, users will do:

class TestMyBranchImpl(TestCase, ForeignBranchTestMixin)

However, I think I would tweak a few things differently anyway.

1) It should probably be called "per_foreign" rather than "foreign"

2) I think I would use adaptation rather than inheritance. Yes, there are going to be *more* tests that will be needed for specific foreign branch implementations, but those can just be created in another test class.

I think having a flag, etc on register_format to indicate this is a foreign format, would be a great move towards making registering the format automatically queue it for the appropriate tests.

It makes it less susceptible to accidentally missing some tests, because you forgot to inherit from the new base test class.

It also means that when we add a new base test class, it automatically starts getting run across all of the current implementations, we don't need to change anything in bzr-svn or bzr-git.

3) I would also like to see things like:
class ForeignBranchFormatTests(object):
format = None # set by XXXXX

def test_foo(self):
self.format.x

It makes it easier to figure out where things are happening.

4) For something like ForiegnBranch, I think the tests you have are ok, though
126 + def test_last_revision(self):
127 + (revno, revid) = self.branch.last_revision_info()
128 + self.assertIsInstance(revno, int)
129 + self.assertIsInstance(revid, str)
130 + self.assertEquals(revno, self.branch.revision_id_to_revno(revid))
131 + self.assertEquals(revid, self.branch.last_revision())

^- this is testing more "last_revision_info" not last_revision. And I certainly thought you wanted to get away from 'revno' since it cannot be easily computed at all times.

I think what we should be doing is designing a reasonable factory interface, so that you can have the test case say:

def test_something(self):
self.factory.give_me_a_branch_like_X()

(a branch with 1 commit, a branch with a few commits, a branch with merges, etc.)

There was some discussion raised by Martin on the mailing list, which didn't quite as planned, but I think foreign branch testing is a *great* place to implement some of this, since a lot of them are going to be read-only sources, and thus doing:
self.tree.commit('foo')
to generate the shape isn't going to work.

If we are going to go this route, I would probably call it a ForeignBranchTestMixin

since it is meant as a second parent class. (eg, users will do:

class TestMyBranchImpl(TestCase, ForeignBranchTestMixin)

However, I think I would tweak a few things differently anyway.

1) It should probably be called "per_foreign" rather than "foreign"

I think having a flag, etc on register_format to indicate this is a foreign format, would be a great move towards making registering the format automatically queue it for the appropriate tests.

It makes it less susceptible to accidentally missing some tests, because you forgot to inherit from the new base test class.

It also means that when we add a new base test class, it automatically starts getting run across all of the current implementations, we don't need to change anything in bzr-svn or bzr-git.

3) I would also like to see things like:
class ForeignBranchFormatTests(object):
  format = None # set by XXXXX

def test_foo(self):
    self.format.x

It makes it easier to figure out where things are happening.

4) For something like ForiegnBranch, I think the tests you have are ok, though
126	+ def test_last_revision(self):
127	+ (revno, revid) = self.branch.last_revision_info()
128	+ self.assertIsInstance(revno, int)
129	+ self.assertIsInstance(revid, str)
130	+ self.assertEquals(revno, self.branch.revision_id_to_revno(revid))
131	+ self.assertEquals(revid, self.branch.last_revision())

^- this is testing more "last_revision_info" not last_revision. And I certainly thought you wanted to get away from 'revno' since it cannot be easily computed at all times.

I think what we should be doing is designing a reasonable factory interface, so that you can have the test case say:

def test_something(self):
   self.factory.give_me_a_branch_like_X()

(a branch with 1 commit, a branch with a few commits, a branch with merges, etc.)

There was some discussion raised by Martin on the mailing list, which didn't quite as planned, but I think foreign branch testing is a *great* place to implement some of this, since a lot of them are going to be read-only sources, and thus doing:
  self.tree.commit('foo')
to generate the shape isn't going to work.

review: Approve

Revision history for this message

John A Meinel (jameinel) wrote on 2009-08-13:

sorry I marked the wrong status.

review: Needs Fixing

Revision history for this message

Jelmer Vernooij (jelmer) wrote on 2009-08-14:

Thanks for the review.

> However, I think I would tweak a few things differently anyway.
>
> 1) It should probably be called "per_foreign" rather than "foreign"
Wouldn't this mean we'd need per_foreign_branch, per_foreign_repository, per_foreign_branch_format, etc?

Cheers,

Jelmer

Revision history for this message

John A Meinel (jameinel) wrote on 2009-08-14:

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Jelmer Vernooij wrote:
> Thanks for the review.
>
>> However, I think I would tweak a few things differently anyway.
>>
>> 1) It should probably be called "per_foreign" rather than "foreign"
> Wouldn't this mean we'd need per_foreign_branch, per_foreign_repository, per_foreign_branch_format, etc?
>
> Cheers,
>
> Jelmer

It depends if you think you are going to have more than one branch type
per foreign type, and more than one repo type, etc.

At the moment, neither git nor hg have allowed anything of that sort.
I'm not sure that svn has either.

In which case adding the extra permutations doesn't seem to gain much of
anything.

John
=:->

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.9 (Cygwin)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org/

iEYEARECAAYFAkqFcJ4ACgkQJdeBCYSNAAMNzwCeIdhUQ5KvUi/8GNUgDyV1TayB
930An1GpW6cnBnBKvC2dwTWPuw4UY73s
=wjYm
-----END PGP SIGNATURE-----

Revision history for this message

Jelmer Vernooij (jelmer) wrote on 2009-09-02:

On Thu, Aug 13, 2009 at 05:09:06PM -0000, John A Meinel wrote:
> 3) I would also like to see things like:
> class ForeignBranchFormatTests(object):
> format = None # set by XXXXX

> def test_foo(self):
> self.format.x

> It makes it easier to figure out where things are happening.

This should work well for foreign branch formats. It's trickier though
in the case of foreign branches, where there is custom code necessary that
creates a branch. How would the adapter find the code that creates the
branch attribute that is used by the member methods of a testcase
class? This seems a lot easier with a MixIn, but I'm probably missing
something.

Cheers,

Jelmer

Revision history for this message

Martin Pool (mbp) wrote on 2009-09-03:

2009/9/3 Jelmer Vernooij <email address hidden>:
> On Thu, Aug 13, 2009 at 05:09:06PM -0000, John A Meinel wrote:
>> 3) I would also like to see things like:
>> class ForeignBranchFormatTests(object):
>> format = None # set by XXXXX
>
>> def test_foo(self):
>> self.format.x
>
>> It makes it easier to figure out where things are happening.
>
> This should work well for foreign branch formats. It's trickier though
> in the case of foreign branches, where there is custom code necessary that
> creates a branch. How would the adapter find the code that creates the
> branch attribute that is used by the member methods of a testcase
> class? This seems a lot easier with a MixIn, but I'm probably missing
> something.

I might be missing the point, but I think you'd have

ForeignBranchTests(TestCase):

branch_factory = None # set by scenario

def test_log(self):
branch = self.branch_factory.make_branch_with_crisscross_merges()

--
Martin <http://launchpad.net/~mbp/>

Revision history for this message

Jelmer Vernooij (jelmer) wrote on 2009-10-11:

On Thu, 2009-09-03 at 00:24 +0000, Martin Pool wrote:
> 2009/9/3 Jelmer Vernooij <email address hidden>:
> > On Thu, Aug 13, 2009 at 05:09:06PM -0000, John A Meinel wrote:
> >> 3) I would also like to see things like:
> >> class ForeignBranchFormatTests(object):
> >> format = None # set by XXXXX
> >
> >> def test_foo(self):
> >> self.format.x
> >
> >> It makes it easier to figure out where things are happening.
> >
> > This should work well for foreign branch formats. It's trickier though
> > in the case of foreign branches, where there is custom code necessary that
> > creates a branch. How would the adapter find the code that creates the
> > branch attribute that is used by the member methods of a testcase
> > class? This seems a lot easier with a MixIn, but I'm probably missing
> > something.
>
> I might be missing the point, but I think you'd have
>
> ForeignBranchTests(TestCase):
>
> branch_factory = None # set by scenario
>
> def test_log(self):
> branch = self.branch_factory.make_branch_with_crisscross_merges()
Yeah, that makes sense. What about something like the attached patch?

Cheers,

Jelmer

--
Jelmer Vernooij <email address hidden> - http://samba.org/~jelmer/
Jabber: <email address hidden>

foreign-tests-4595.patch

Revision history for this message

Ian Clatworthy (ian-clatworthy) wrote on 2009-10-14:

I'm going to change the status to 'reject' because it looks like this has been superseded by the merge proposal for foreign-tests1. If I'm wrong, please resubmit this.

Updating diff...

An updated diff will be available in a few minutes. Reload to see the changes.

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Aaron Bentley

Denys Duchier

Eric Siegerman

Gary van der Merwe

Jelmer Vernooij

John Szakmeister

Jonathan Lange

Marius Kruger

Martin Albisetti

Matt Nordhoff

Paul Hummer

SuperMMX

Talden

Yoshinori Sano

to status/vote changes:

Alexander Belchenko

Martin Eisenhardt

Tim Penhey

Vincent Ladeuil

 === added directory 'bzrlib/tests/foreign'
 === added file 'bzrlib/tests/foreign/__init__.py'
 --- bzrlib/tests/foreign/__init__.py	1970-01-01 00:00:00 +0000
 +++ bzrlib/tests/foreign/__init__.py	2009-08-31 04:36:07 +0000
@@ -0,0 +1,20 @@
++# Copyright (C) 2009 Canonical Ltd
++#
++# This program is free software; you can redistribute it and/or modify
++# it under the terms of the GNU General Public License as published by
++# the Free Software Foundation; either version 2 of the License, or
++# (at your option) any later version.
++#
++# This program is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++# GNU General Public License for more details.
++#
++# You should have received a copy of the GNU General Public License
++# along with this program; if not, write to the Free Software
++# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
++
++
++"""Tests specific to foreign branch implementations.
++
++"""
 === added file 'bzrlib/tests/foreign/test_branch.py'
 --- bzrlib/tests/foreign/test_branch.py	1970-01-01 00:00:00 +0000
 +++ bzrlib/tests/foreign/test_branch.py	2009-08-31 04:36:07 +0000
@@ -0,0 +1,121 @@
++# Copyright (C) 2009 Canonical Ltd
++#
++# This program is free software; you can redistribute it and/or modify
++# it under the terms of the GNU General Public License as published by
++# the Free Software Foundation; either version 2 of the License, or
++# (at your option) any later version.
++#
++# This program is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++# GNU General Public License for more details.
++#
++# You should have received a copy of the GNU General Public License
++# along with this program; if not, write to the Free Software
++# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
++
++
++"""Tests specific to Branch implementations that use foreign VCS'es."""
++
++
++from bzrlib.errors import (
++    UnstackableBranchFormat,
++    )
++from bzrlib.revision import (
++    NULL_REVISION,
++    )
++
++
++class ForeignBranchTests(object):
++    """Basic tests for foreign branch implementations.
++
++    These tests mainly make sure that the implementation covers the required
++    bits of the API and returns reasonable values.
++    """
++
++    def test_set_parent(self):
++        """Test that setting the parent works."""
++        self.branch.set_parent("foobar")
++
++    def test_break_lock(self):
++        """Test that break_lock() works, even if it is a no-op."""
++        self.branch.break_lock()
++
++    def test_set_push_location(self):
++        """Test that setting the push location works."""
++        self.branch.set_push_location("http://bar/bloe")
++
++    def test_repr_type(self):
++        self.assertIsInstance(repr(self.branch), str)
++
++    def test_get_parent(self):
++        """Test that getting the parent location works, and returns None."""
++        # TODO: Allow this to be non-None when foreign branches add support
++        #       for storing this URL.
++        self.assertIs(None, self.branch.get_parent())
++
++    def test_get_push_location(self):
++        """Test that getting the push location works, and returns None."""
++        # TODO: Allow this to be non-None when foreign branches add support
++        #       for storing this URL.
++        self.assertIs(None, self.branch.get_push_location())
++
++    def test_check(self):
++        """See if a basic check works."""
++        result = self.branch.check()
++        self.assertEqual(self.branch, result.branch)
++
++    def test_attributes(self):
++        """Check that various required attributes are present."""
++        self.assertIsNot(None, getattr(self.branch, "repository", None))
++        self.assertIsNot(None, getattr(self.branch, "mapping", None))
++        self.assertIsNot(None, getattr(self.branch, "_format", None))
++        self.assertIsNot(None, getattr(self.branch, "base", None))
++
++    def test__get_nick(self):
++        """Make sure _get_nick is implemented and returns a string."""
++        self.assertIsInstance(self.branch._get_nick(local=False), str)
++        self.assertIsInstance(self.branch._get_nick(local=True), str)
++
++    def test_null_revid_revno(self):
++        """null: should return revno 0."""
++        self.assertEquals(0, self.branch.revision_id_to_revno(NULL_REVISION))
++
++    def test_get_stacked_on_url(self):
++        """Test that get_stacked_on_url() behaves as expected.
++
++        Inter-Format stacking doesn't work yet, so all foreign implementations
++        should raise UnstackableBranchFormat at the moment.
++        """
++        self.assertRaises(UnstackableBranchFormat,
++                          self.branch.get_stacked_on_url)
++
++    def test_get_physical_lock_status(self):
++        self.assertFalse(self.branch.get_physical_lock_status())
++
++    def test_last_revision(self):
++        (revno, revid) = self.branch.last_revision_info()
++        self.assertIsInstance(revno, int)
++        self.assertIsInstance(revid, str)
++        self.assertEquals(revno, self.branch.revision_id_to_revno(revid))
++        self.assertEquals(revid, self.branch.last_revision())
++
++
++class ForeignBranchFormatTests(object):
++    """Basic tests for foreign branch format objects."""
++
++    def test_initialize(self):
++        """Test this format is not initializable.
++
++        Remote branches may be initializable on their own, but none currently
++        support living in .bzr/branch.
++        """
++        self.assertRaises(NotImplementedError, self.format.initialize, None)
++
++    def test_get_format_description_type(self):
++        self.assertIsInstance(self.format.get_format_description(), str)
++
++    def test_network_name(self):
++        self.assertIsInstance(self.format.network_name(), str)
++
++

Bazaar

Merge lp:~jelmer/bzr/foreign-tests into lp:~bzr/bzr/trunk-old

Commit message

Description of the change

Updating diff...

Preview Diff

Subscribers

 # Bazaar merge directive format 2 (Bazaar 0.90)
 # revision_id: jelmer@samba.org-20091011013123-zbcruv13w8q2h6r5
 # target_branch: http://people.samba.org/bzr/jelmer/bzr/squash-xml-\
 #   invalid-chars
 # testament_sha1: 32984381e00180079b59a5192388743b5ddf002e
 # timestamp: 2009-10-11 03:33:30 +0200
 # base_revision_id: pqm@pqm.ubuntu.com-20091006204548-bjnc3z4k256ppimz
+#
 # Begin patch
 === modified file 'bzrlib/foreign.py'
 --- bzrlib/foreign.py	2009-10-06 14:40:37 +0000
 +++ bzrlib/foreign.py	2009-10-11 01:31:23 +0000
@@ -36,7 +36,7 @@
  """)
  class VcsMapping(object):
--    """Describes the mapping between the semantics of Bazaar and a foreign vcs.
++    """Describes the mapping between the semantics of Bazaar and a foreign VCS.
      """
      # Whether this is an experimental mapping that is still open to changes.
@@ -122,6 +122,8 @@
  class ForeignVcs(object):
      """A foreign version control system."""
++    branch_format = None
++
      def __init__(self, mapping_registry):
          self.mapping_registry = mapping_registry
 === modified file 'bzrlib/tests/__init__.py'
 --- bzrlib/tests/__init__.py	2009-10-01 14:44:43 +0000
 +++ bzrlib/tests/__init__.py	2009-10-10 22:28:00 +0000
@@ -3650,6 +3650,7 @@
          'bzrlib.tests.commands',
          'bzrlib.tests.per_branch',
          'bzrlib.tests.per_bzrdir',
++        'bzrlib.tests.per_foreign_vcs',
          'bzrlib.tests.per_interrepository',
          'bzrlib.tests.per_intertree',
          'bzrlib.tests.per_inventory',
 === added directory 'bzrlib/tests/per_foreign_vcs'
 === added file 'bzrlib/tests/per_foreign_vcs/__init__.py'
 --- bzrlib/tests/per_foreign_vcs/__init__.py	1970-01-01 00:00:00 +0000
 +++ bzrlib/tests/per_foreign_vcs/__init__.py	2009-10-11 01:02:28 +0000
@@ -0,0 +1,47 @@
++# Copyright (C) 2009 Canonical Ltd
++#
++# This program is free software; you can redistribute it and/or modify
++# it under the terms of the GNU General Public License as published by
++# the Free Software Foundation; either version 2 of the License, or
++# (at your option) any later version.
++#
++# This program is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++# GNU General Public License for more details.
++#
++# You should have received a copy of the GNU General Public License
++# along with this program; if not, write to the Free Software
++# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
++
++
++"""Tests specific to foreign branch implementations.
++
++"""
++
++from bzrlib import (
++    foreign,
++    tests,
++    )
++
++
++def vcs_scenarios():
++    scenarios = []
++    for name, vcs in foreign.foreign_vcs_registry.iteritems():
++        scenarios.append((vcs.__class__.__name__, {
++            "branch_factory": vcs.branch_format.get_foreign_tests_branch_factory(),
++            "branch_format": vcs.branch_format,
++            }))
++    return scenarios
++
++
++def load_tests(standard_tests, module, loader):
++    result = loader.suiteClass()
++    per_vcs_mod_names = [
++        'branch',
++        ]
++    sub_tests = loader.loadTestsFromModuleNames(
++        ['bzrlib.tests.per_foreign_vcs.test_' + name
++         for name in per_vcs_mod_names])
++    tests.multiply_tests(sub_tests, vcs_scenarios(), result)
++    return result
 === added file 'bzrlib/tests/per_foreign_vcs/test_branch.py'
 --- bzrlib/tests/per_foreign_vcs/test_branch.py	1970-01-01 00:00:00 +0000
 +++ bzrlib/tests/per_foreign_vcs/test_branch.py	2009-10-11 01:20:37 +0000
@@ -0,0 +1,151 @@
++# Copyright (C) 2009 Canonical Ltd
++#
++# This program is free software; you can redistribute it and/or modify
++# it under the terms of the GNU General Public License as published by
++# the Free Software Foundation; either version 2 of the License, or
++# (at your option) any later version.
++#
++# This program is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++# GNU General Public License for more details.
++#
++# You should have received a copy of the GNU General Public License
++# along with this program; if not, write to the Free Software
++# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
++
++
++"""Tests specific to Branch implementations that use foreign VCS'es."""
++
++
++from bzrlib.errors import (
++    UnstackableBranchFormat,
++    )
++from bzrlib.revision import (
++    NULL_REVISION,
++    )
++from bzrlib.tests import (
++    TestCase,
++    TestCaseWithTransport,
++    )
++
++
++class ForeignBranchFactory(object):
++    """Factory of branches for ForeignBranchTests."""
++
++    def make_empty_branch(self, transport):
++        """Create an empty branch with no commits in it."""
++        raise NotImplementedError(self.make_empty_branch)
++
++    def make_branch(self, transport):
++        """Create *some* branch, may be empty or not."""
++        return self.make_empty_branch(transport)
++
++
++class ForeignBranchTests(TestCaseWithTransport):
++    """Basic tests for foreign branch implementations.
++
++    These tests mainly make sure that the implementation covers the required
++    bits of the API and returns reasonable values.
++    """
++    branch_factory = None # Set to an instance of ForeignBranchFactory by scenario
++
++    def make_empty_branch(self):
++        return self.branch_factory.make_empty_branch(self.get_transport())
++
++    def make_branch(self):
++        return self.branch_factory.make_branch(self.get_transport())
++
++    def test_set_parent(self):
++        """Test that setting the parent works."""
++        branch = self.make_branch()
++        branch.set_parent("foobar")
++
++    def test_break_lock(self):
++        """Test that break_lock() works, even if it is a no-op."""
++        branch = self.make_branch()
++        branch.break_lock()
++
++    def test_set_push_location(self):
++        """Test that setting the push location works."""
++        branch = self.make_branch()
++        branch.set_push_location("http://bar/bloe")
++
++    def test_repr_type(self):
++        branch = self.make_branch()
++        self.assertIsInstance(repr(branch), str)
++
++    def test_get_parent(self):
++        """Test that getting the parent location works, and returns None."""
++        # TODO: Allow this to be non-None when foreign branches add support
++        #       for storing this URL.
++        branch = self.make_branch()
++        self.assertIs(None, branch.get_parent())
++
++    def test_get_push_location(self):
++        """Test that getting the push location works, and returns None."""
++        # TODO: Allow this to be non-None when foreign branches add support
++        #       for storing this URL.
++        branch = self.make_branch()
++        self.assertIs(None, branch.get_push_location())
++
++    def test_attributes(self):
++        """Check that various required attributes are present."""
++        branch = self.make_branch()
++        self.assertIsNot(None, getattr(branch, "repository", None))
++        self.assertIsNot(None, getattr(branch, "mapping", None))
++        self.assertIsNot(None, getattr(branch, "_format", None))
++        self.assertIsNot(None, getattr(branch, "base", None))
++
++    def test__get_nick(self):
++        """Make sure _get_nick is implemented and returns a string."""
++        branch = self.make_branch()
++        self.assertIsInstance(branch._get_nick(local=False), str)
++        self.assertIsInstance(branch._get_nick(local=True), str)
++
++    def test_null_revid_revno(self):
++        """null: should return revno 0."""
++        branch = self.make_branch()
++        self.assertEquals(0, branch.revision_id_to_revno(NULL_REVISION))
++
++    def test_get_stacked_on_url(self):
++        """Test that get_stacked_on_url() behaves as expected.
++
++        Inter-Format stacking doesn't work yet, so all foreign implementations
++        should raise UnstackableBranchFormat at the moment.
++        """
++        branch = self.make_branch()
++        self.assertRaises(UnstackableBranchFormat,
++                          branch.get_stacked_on_url)
++
++    def test_get_physical_lock_status(self):
++        branch = self.make_branch()
++        self.assertFalse(branch.get_physical_lock_status())
++
++    def test_last_revision_empty_branch(self):
++        branch = self.make_empty_branch()
++        self.assertEquals(NULL_REVISION, branch.last_revision())
++        self.assertEquals(0, branch.revno())
++        self.assertEquals((0, NULL_REVISION), branch.last_revision_info())
++
++
++class ForeignBranchFormatTests(TestCase):
++    """Basic tests for foreign branch format objects."""
++
++    branch_format = None # Set to a BranchFormat instance by adapter
++
++    def test_initialize(self):
++        """Test this format is not initializable.
++
++        Remote branches may be initializable on their own, but none currently
++        support living in .bzr/branch.
++        """
++        self.assertRaises(NotImplementedError, self.branch_format.initialize, None)
++
++    def test_get_format_description_type(self):
++        self.assertIsInstance(self.branch_format.get_format_description(), str)
++
++    def test_network_name(self):
++        self.assertIsInstance(self.branch_format.network_name(), str)
++
++
 # Begin bundle
 IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWVqfm5cAGnX/gE5QAQBY////
 f/ff6r////pgInXdzFr7nA8PDpml9zJfc73vS9PSa7m9toG2Cq06A6DqtNCg3uea7R1udnvNxpPI
 ZpneYaD28rr3e6zEt5OcUddenlO93Tt06vLvDe9uR2wBhJIjIGgCAmENER4Umyj0mRmo009T1B6m
 DR5QSQgBAgmiTIo8o9RtIA0ZBoAAAABpkEFFDQBvVGgANAAAAAAAAEmlImmUam0BU800EhvVPUe
 ptQbKD0IAaD1PUA2UEUgqehppqan6jTEFPNU2nqanpHlNHpNqegTTRk0ANNARSBCZNNCnimnoCno
 xU8KeptQANNGhoAAKiPVXQm9hxAIcW+fu/igFST0YTsDN5LW9C+LQhHiTR3ceT+U726IlUfn2M4
 C7+UEseV9Hxpmf/mqhV8mM8guGKBqwKi9KeDOZQ37dHW+3Et9415hvvkIQ+iJv0ESR8Rd6MnWNva
 eBsbLuRpqMw6sRw4l7+vcu3wH3kfZWKElxLXMPJxOy0wsWm7fJN89Y2VEjdtj5n9V5S1b7ds1kuG
 tDkNmEkbrTNQaUIdDCcBlTDmYLJjGKHb/7Hn+B7OC7+fnnKf2E+Q8fPyB7j0kpyHMHyw6xNDwQqM
 aCocBdnyN3Xscp34mMd18zjdr4tLmARZsyoZshKwkr4gKMJI7EprAYZ2vD2YVTH12Gs08XnGqRTW
 RVBVVPNIKg9EG2pgRGWFjTwIVWAwKIqLMTxQxi73lKs6MUZmC4icE2Zg8pCSNbER7eMHhvsAqmpB
 eBAABwneVAtE6BcTQ/fw2z+bXyyQ9wTsgaMsgIwUEUYKsFgiQBQPwZ957whOrxdfHfrDaUWK+LCO
 yMPBiCzvDjBYkYLRSFFpK0NGmsZbRCxqBLMBaap0kRJIhhuBT6aB9y+qb3KSZALKBszTJyrC41zd
 wWEQhRkxgBBWQMhJysG5aMDXTzNk7rKESqLXZ8WjJGWMODLi1LhAtkzNnpWwnic3dhEKCsuE98Xm
 Fqy0CTLuhRzEG0C11ktc2IsRikTX1DDYbb4vLZyRu4AYD3HgbjvO3UbvgWnM7hjrIFhCi4UYlZqG
 Ace8VJ58hTnxJiA37sGBwh1ZDsMygXeUhOHaOFEtJplcI+BtIlqhrWXoHtXvZ7k95PEndVN35Efy
 sOBApHz7bFWZFG745VDBF325XCnMpyBbkQLidTsbw/5Pn/327mz1DwR1/KPLTbcFb7omDDAoTD+7
 yeeXtc9m/Nj2MiGdX0AysaVtikRUIghz/ivFpFHGJKtbx3DT0PPkgrfcid/YjJzsVKozaR0PDn8j
 H1JIv5mZLXKkYJTd8uOfjJKho+hSFI0QLrx457QEtpgbdZlBy0gBlvccc4piwTOOkh4sfI+3nVqH
 xsWl5oOkV3LIzbsgPqJHifQAakyYYaunLGx7DisVYq/uDxwMQSybyTwiZv4yMSCcmdkMSkGJlEiS
 tOofecc3vsHzkw80EHhu+mu4d4T+Xiefhbc6rdAqH+KJBYegF1Em2tOPNnKq2tfVgWPKQ4nPs8Kd
 /Py5Dg59TflXxq3w0o3toZCDtR9a+71/teAzJ45MMgeNOkGlLMufHe5zqkIHOZr9NuttlR1bpIK0
 MgYR5DE+oLD9IhBGAGDK0SKSdBOgQwIwEiQv9XZaHd2XGINzAmS2341nKSJBC+KOqdSdaNEM8N7S
 PeBnOzLJQdVAYCDwjFVBgGmYkWhzhzVVbGmazTVLA5lFYSgiSfUW/EHa792Pi5djtvsTGuzDNyVy
 VqZooKVrNU2x9WCVVzoLk3ErPRtyn8jq5jSTgnvZbxgnITyZVaGHdftMbIlt+EMkES9HU/45Y8S3
 n2io2wFvuNiRYPwmewGRzWZlCcwPTZhykEoO2mOQ5NIGac5pqZl8nw9LPsVWljZGQ5Rk/ROwLwgf
 ANqskTxFSlAkgxLSTNBfN+4GRB6Q8QWZCQUANjVWSPTNGBKiWiYhTq1CdQJPGOvdExCUQrkVgden
 H0S1Tu/cwTFP+cdOTduvL/+SPg44qzcM3Z/FfnyD/QSDQyQDhk86eLj7QNbLeUaUu+Q7s5z2LXFV
 gPHFdMwbZyGTIKwibT7Wh6yEAwbTfxEFVMwmMlmLlAGq03uU/EblSpf92/790vtLBqnTjbfz9IW0
 tpbbbLaW2W2W22/Icmuw6a67e6Tt+697ng0xxCAvduoZoSC5oCzck70sHXAhdfBcJp8AkTUsLci3
 dsSK91EYHfOcWDkUkGkkoqSNNNlpUSzIWNCBEiBW0Ca6SGhK/NZl7dsulDA6BsIEvoIlfdg45aq2
 yewlOiEeSsGOFcybgKJFzpu9SFcCxXpI4kS3DcgwfZegbXwG4OsBcSLwSqVC9ZBZulAolhgAz0cC
 DfBl7BLi4W7WwExRJqwiptWWIgbILFNWygpSUgRxuIZIZIg88tMwlktZOMHCvXHKVzejub0ZvjpO
 GeZDm5Vi0CJaEXxQKFOcqP0ELpJejrkhfvoN3vBz1ympSsAJvVlEQRPLK+EoiUqd6Kaer8yVWgeT
 EEmKyneliQxhJHnNxPmIJdlIxkLJEkgwO1JgNCEHuhzSC8I+AJtz+wS+phhIwKCsrDBUceVClYbM
 F0GAmoTltpiXoSJDGsdwekm6MML83me486lukH1Z9RttaM5Ld7FGx2l1KUCKFS+/sPLiIs0BaYZg
 i3Wa08rcy6xExnlj3ihbZUwC3CJF9VkjQhGRdam+vWJLoEg2nerW5R8aOhHT0En7u27sbgXXwkqc
 MzLECdqnnBxPKDhaXzzkSvd1VBYl2yxLyw3G/O4wxyl1FirnBGgD5YLFCeiir4vyOSV9zZcGplM
 GDX0nQoJFTKe+hzngnxk9fRZK03mkOwDSZwKzyOcUz1UT5cGvEnu8yeQoOGUlUV5RRWqgHGSBIkI
 kuMoKKW9wj0ZoakEzlW3gRkqKLzJsYwU4lhEjBVIuiiE6SkCg3sKQBCQ4d6FepItRpQt4JXypq0D
 nRwAOjTpx6nUjIytBfJ1QSNCUjQgrBnKmPMPepYMRCjlHIoDE1ZZFt6sZgf6AlMX5k79loJFhzQu
 q8jG1jxouaVtXi0jg6KkGNosZPJ+wL8ADfHdLPGzQkSeUn53h3iUgR+SwoN5iXkc+TEG5PKkd9dk
 QJybpJyXS27JLPdYNwB0sFsHQ9yCKCJNwSkVYOvIht4BhHFglmXH1zwCLHNgsQTJvafS2CZzzs6R
 ZEmSYZY5HkkpOY+aQ6UxtIQs556SJ1UKaV0HsWXl8yklEwqEY9s8c+RzkmcEi86TJlVlvBkoIvvP
 lT2YrjQxUlVfdVHK2KFtQOD3elCkK8AoW8M9Vemf0jTU4eIAYt4nSljvJpY5eaGMp2CmT1Rs6gqX
 JcWFJsCBiQInAguOBwyosXBq9PKlAFxgRSiiFjaF4YXGFepJkKY+/RKDgEWmMpnNDZ34riP0qLjn
 p9bwU8Ba+TiSscu8264oU5EjadNTjNurfy7pnzdFNB6eTo88nawWCgsFikWDMmPOL6VjhbhPOItP
 cRAhqMkVEBuN9q8JPZBPk3ioU9iR6g7uFi2w1i0za8e2RsHzX3h3SPohbpLg+s589fJQHLQtpIwN
 eu71d3s9nJ/L2uSq5nTNOYi8pUyUQlOnuRoFAePgMA69rG4Zyhz0fDy9J9MdG6GOxgR2t1Y5v3hD
 +UGOCZ3wbrxffK7c/fnbABYSZDNtrfYeKXok2S5ulF51KkoVrYazPxbkzZCo7GNL5txL7gRQtMR
 uqodhppNc7QkZVBTyBD3ATHAvSV6KdJ4U2G90r+mIPlxo1c1BQkTJW9tnQvGzBFHfqaTytmpcpVp
 dUCdLAXok69ZRyXOqmcZznfCCxuplGuVopMFwjooeWOElUblTLpixuYEiUEj1KsivPVuld7Ged7G
 is7JhzPCu1DhcjeXKTpWu3uI3QB4ODniIScjsceuYpxoZijrDnJwKBM1dW9oTLzyV7A0V4Nwp1j
 zFv1I6j2ywt+vYY9Wb3jqzRJnu9QkJEJDUF2klzSVMwYkpEeVaz5cs6G/uFM8Qv5HP2ib56HM23N
 BQvM1Q19Ou4fDyse1rIzEYGmomXXySNiyu/rWMdqs+oyWV97zlAiWNbDZsmINg6+MZjOebUOIAG
 XERyIRSoTiffC3LnVSOzxYksPPGL7pLaxl17fiQvQlZJaPXbBIczEpvMxJezJsRXsaCjq6FZWVr+
 BRS2e3EUTDlNd+anQhslneMyFcChNPytKfnbycnFX8tw1Cly88mTWTOwWVL5JEqb8q2xmREDmybv
 HBImbLPxbGQoU6MhsceOxI1PgMpYKQk0z37LcvmgiEIVfcQ/RC5Y4PBHgJHOdyFo9BuRrv3ta55t
 ghuY0zm9HrybEG42BcCTR+Y+Q3iXbNuRtI45pmUdGJITtS0TJ7RAzPEsFn8S60rasIMacNMCALJ
 aO4vViaMjIEvLJV2lvORIsVnBctxltVN5iXBll8vfR47BfpTxgERhUsaoWOQ3Gt2NUwOk/btY5Tn
 RaRB7E9Nx3YzncL0go3TK2J3NFDhj3BF+dJ7m2kuvHjkzQtfR4z8hI80K7E5duu2iM5Pg198a8zf
 ckr+sRWCOQhweaSX6FhsY9Bis26JJQv35UoJSN6l8E4GYkGkSBLBNQnASLCSRGkrhKABMSQiQiXC
 SlQAMFEteJAkvA7T6zgflQDrUWScRIZwVUWIIzxQpELGJbCMZvgooqxRYsVWpGRk6g6ofjgDBJ6i
 G5ouU5fmEQJ9h8C89J/Z7SYdp/p8TwNDeE4FRFYIEWey2As/qdZn9LOqZ0Sk9pwPhP5kDgimh449
 I1uZoQqEPPaORaIqQcVWLwraY/AojN7ICQndAP3nEaiDsM6b6cJ/hxkGZyFoL8XgLWImzPgbhkUo
 mBfMYho3d1IxOQfIXIo7HTHOYW8ZImBMZAM4+RSYIxEaG4tEdCkkQHATDx5zKRHuRrGEMThsW048
 BicqLk1HRrE6CD2WS4hO8vNCCx5pgkypJeJ6ohxf2DMdJikHnQoFgMiY2DFo0a8HrFDCXAuMZpCj
 og95Lj72tXYloltao+qNA8DATnX2xEMVRFURZIoqlhDcmrMiE++w8MgY9MpqMmIvNsG/AaQGIyDN
 ChYEkmjOaiQWH6g+LiSbdJYCAhWkVhfraUshoKFj563kEi2TUvmBBGYHybgiBHph+yZin2XCJ5T
 y4EwDk9RkPP3Fs5Wk1gDGjWmDBH5zQ9xz84ZI+o2xASDOOcMPIgcwbTGGtLZoESkgJ5T+RZ8rz+E
 xo21UGWBiSvUj79oF/62ZkzJLI/BcTeFow5S5ay9sx0TZWtpeS25pchHIomB2kj6XOHoKKpvlRj3
 EL7F4OuCi6g9lw6xEDtAD4xsEvMSQBYFRmhIyGZ8yFlBQ85vpDpOrxCZ9gXQdwqGsDS8oUq3GSR9
 ZyxA1ihC6080hgggiL4PmTRbM44RhigwByNUw4CnycFQTK/32m5B5cvH0GfceSz8NxdwL6HrLBXh
 oAeNtUX2hcPAqntseYTCZs7CxnoSycTy1GmBthIimGulQTm7REC48z4mhwpr1HtDSmYvWBh5i02Q
 IMxQUgFiVJoTwLMoN34m6YjTqig8IhYrktYGo18ACPrBBJB/XtJId87xEVyb4SGxcC6Z0XDX7Grp
 CFqua6+UzykmDBYXOSjl5SQ8EhgOwloE40UykfeCClkICKR10CRtN2zt3+pC4lHX2nEh1FA3I50D
 njYGrpeoPTXkjoa+NmWHWksiswWSSniYlZ2vK5wzeFxnChjyBicK6wnTfRUtq7gZcByDLQlCo1F7
 bSYpz1pBnsN76dJFP1AZATzcTbYlSC9ERtv7DtotxpbhMggiSSlISGYHNHsG7yQ6NQOJ0iQG0O
 A/DXAObRGNYyMIOW7Ux+FOIg8+DEpTAUwXcFp0nk56iYYbshM+g5WeeRXp7MXJbqlSWwTq6y1o02
 oBlVpoImG4x0hdWrpDETQsVM1Bm7OkkE38Byt5bkqDOIViYrybAdhUr5j2qJYY24y0M+wSG1b8Ss
 OSeO4kjZfjbJP+oANx8kolZIW0AcYCYhLGvi4jqPkKJyzKECUtCJ8WzcobNuShg+01LBPqwBdbGz
 KsyhA5ipaQzGhq3e5pOQU7jTMmTGjzyXNG47Bkj9mCTBUR+qQE2iYwil44mH2PGcJHeO6KRtOxXT
 TPxuzzl06o44bbDuw5GRSUrIi9qyLunVkWTFk0KyHfKQTA0aYD9TjS/Nh32Q02bXZn9oz6bNsNt
 D2jU6iMX4GmOJuS02DysuSjqLtsidm1vh3NQNTuN81zH06G5GsAYQUCMhh5YgIhIElELDpZzlrK8
 SKTVNCibxpcbi823AbTGjYMqcCBsORSj606ZJzdho6cqedo2o3DloFlAvxYYYwxil6DiyPoGnNBF
 Tdd2erGW/hKkRwEeJA5gLeGLo6JYZ38KHVlVMMRDxJK89JE5CUxPRpnnoVbhFs+Xa0OemRQI1w0G
 atJ4foIYEcsQEB8xHYIQGx/RI+43h5AB0q2Hcnagd/1koHd5iA8KQKQ6bvJJiwCbSkN/MWlCUQ9
++QlRECqcwy7ravAHvE23UhKihmahMNZa0mtLNaHw+df36PMSxu+RYT611CQkKhISBksARCRClF+A
 ek+XE9wmhDEMEMQNxAG0UicRiU2q4FjY8jVVDPLWInb57RNwWiNBghAkBBUAAwPeeXjP0+A/to8c
 WLZ9Q49nreqavNy83PTy0p2SHU3k5cmYtIyvNmupTwN4puka/FWKlM3EmbDUjasLbLeX7NTjsxmo
 xI/D4YQcapYguOdpuNwUklTcPBwXZgAkY70LSVpwABVWD6wDximdU43UWHx/N7cfEZDPL6SwnlIZ
 WYjPEHqyu5sSYViJCQ2EiU4P1bZaw7gNDtGpgJ7Roc0dyT5QAB0QoTyQhEk4TwSIoo8GhSGItski
 hjUsxjXtR3OsA6jYiHhOiQEEpQRMiAhRWA7BcaHOj0DkE5gsRxEIuAxAiyB0dckXFPXHH9N4XlLE
 fkJFF+JJgIDz0yLwoeKu0X4HccA9odqClym8TmhIF9XahCwOTkcyQfrArMAsfMOYnaoMoYkJjNlR
 KYB84AaT1ki03QB1qwL5kNQnFgitTnOJXMCXC6mHOQmRRNO8VnuuDYUI5Tsjex7DIxonn7hPoEzE
 xxMYYRRQUEkEZIDJQEZ/jrOyTrPYcsUGAtQ+0xAA9kQ7KAOKFYUNlsXwLRxAWB7PWwh3sAIF/tSG
 FMAN3CM5VgFQeo9ImDcAliUiWJSJRsEoMpEsSglBlkSgykSjQSjfGQ17YTTSefmJPOLHEd9LpMgY
 IE8jUeQKtB1IzDcIRSYSO+hsUSfALyDrOvIiVRxgd5iJyiINORgAkw6EBsJMBIssdVrx98dlDMgk
 X2DtyAOLOJCmTJnNU9inRcAgbELDQ4GyZjotMCR6xMTh9RITIEQmsQ6YB4BDuGIXKZDwmY+PSKUW
 gLRuXcEgnhqcDAsSoSCQPsUk9QalewSxVS20N6kECMMPWPCfrOgEZPYAYCIHfGBEQxBmEAMF84E
 PQCIWswJsBKKWB6DUN5cJcAEQPemFMCDXId6gRgaQVo07EhjmIcWUKRSlKEGAziZVmlrR2k0ZwH
 sJKyBgRPRSGeCFklpCWAgCwQeJzx87JCTgBTaexzAMwhQFrBmokHWMDcIGgYQ0xdBioKYyqDDkC7
 iISCxJz8ezARiKQ1JCSHcJabEQFsQLL/JmGwGiEoASVJABOFEyUmerXUV4o5gmNjrVr9HNsDdhlC
 TJIcCnUCZKuhMDKaXfoicYUj0zOUqjlFPOF5iXpQ9eUT0IToJeMJIGLF0a6A7xxIENDIkql8IHIL
 /uGsKPWJnJmPEOgmJQszbCQlhcdZIMT4yAlAVwIN1RPIHeJVAHqQhOcRAmbRJhlGKCrAEZJp6JJ
 mSSdElPrPN1HYAxVhb5gjmfmaguB5ulMa79pLUWWCJCNwZEfVFdI+8SQhAiRcAGBoaHx5W8eZ+id
 mQBLJsG1HfL5kwjKsdJ0dDD0h6FMFKuVZCRUMTMjEEKBrGhoqkGofcPiGsUw+lTYKfahsLh+QJJ
 qfpMUmJpEhMjUUnEFBtYchu3UChuZDdQ773CaabzIxjIJ4IUGwUDHBiUT3YTHwDqQTbBECqwjAId
 xcH4M3QqDLATOTnF6vZ5SEvE73GiBiQaF8Y7zhzCrO64EL4ETmPGWZTRGjZEmURJiSVay5JByifa
 JRUnAlGRKUgq5hEDWcKscdw29hYnohV9xd32DgrA9IdiMgRqTWA2ikCSDmw57uHSPQJJOTOYVE4g
 iZbzt18LAsAJSBJd5wGSIa4EfMztSkeI0O9ipNiC70ITTd9rupkoj0QJ6ldoGetqGbsml51Y0tSD
 gUNJmIHpCPyplsTGmEEli7EbMWgnk/UAQE8QTDXOzEMhOIiB2n0Rxe+8LkJhEjIYMfsmNDMGU5g
 vERH9gkViQMA8Cv9EMDJMKLECPeHziY5fN1EgcZ3nSjuMcAN3rEUFFigoMQmYBkZnK8Z3hfHM5I
 jAJ3GNADpJ+dBYoLFiwUFFiw5j8RDOc78OXuweGTAGhBJA90lFksE3EKzEmAS5RRzzNyiURmERYq
 HHYaJrU3rJOLWLwjqi7QNC8KOovJkiA/suOSZVtQhFxMNsFCBi1IExUYsAw95SOxgq3tjAJFlMKS
 vKllgL0dXQJQSibSG+MhMGNYRgSzYLDYgIUiyRIfOAFJQEQkwSgUNx+49ehqPIbGxCNUzKTPxbE+
 oSm4rceYTIDjI6l7lhZK84KQSDnDKUTJ9wkwA5CXmKTUSCFgzE28RSY6cFPUCbg5XgbyCCAiByPk
 jeZA3tiKdsGgSokXEBISFYEtPNAFVNDzampkGY6PKyuyOKAbMnMkMyEMyGgdZcJRSlFJhCu4E3jJ
 NzYhANhUMlLwD86EsX+Y3HJTT8Ip27Tl7wTTI9OXyR3nHcGJ6Cgll1FQ5H4w2KVCw1ZPEOCmNJBe
++gC8oQecDvGyu46e4e9HXi6zqkSCHpekwfQK7KmcFqpSLQghrBPpvRnVyGo3vahIkZqwtAClSdWA
 O0Wiv4EcATQWPzKSHFRPR1+k3HGcne5tFDUVJk+RK1pgFBhVgTCBHzQ2C8FIvADApt7B84BJBU1H
 rDHLNXBB4vXtRqbHiMNCACI3q8wBAvhtExhvhcEIaM58D/xdyRThQkFqfm5c