/brz/remove-bazaar

# (C) 2005, 2006 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

"""Tests for bzrdir implementations - tests a bzrdir format."""

import os

from stat import *

import sys

import bzrlib.branch

import bzrlib.bzrdir as bzrdir

from bzrlib.branch import Branch, needs_read_lock, needs_write_lock

from bzrlib.check import check

from bzrlib.commit import commit

import bzrlib.errors as errors

from bzrlib.errors import (FileExists,

                           NoSuchRevision,

                           NoSuchFile,

                           UninitializableFormat,

                           NotBranchError,

                           )

import bzrlib.repository as repository

from bzrlib.tests import (

                          ChrootedTestCase,

                          TestCase,

                          TestCaseWithTransport,

                          TestSkipped,

                          )

from bzrlib.trace import mutter

import bzrlib.transactions as transactions

import bzrlib.transport as transport

from bzrlib.transport import get_transport

import bzrlib.ui as ui

from bzrlib.upgrade import upgrade

import bzrlib.workingtree as workingtree

class TestCaseWithBzrDir(TestCaseWithTransport):

    def setUp(self):

        super(TestCaseWithBzrDir, self).setUp()

        self.bzrdir = None

    def get_bzrdir(self):

        if self.bzrdir is None:

            self.bzrdir = self.make_bzrdir(None)

        return self.bzrdir

    def make_bzrdir(self, relpath):

        try:

            url = self.get_url(relpath)

            segments = url.split('/')

            if segments and segments[-1] not in ('', '.'):

                parent = '/'.join(segments[:-1])

                t = get_transport(parent)

                try:

                    t.mkdir(segments[-1])

                except FileExists:

                    pass

            return self.bzrdir_format.initialize(url)

        except UninitializableFormat:

            raise TestSkipped("Format %s is not initializable.")

class TestBzrDir(TestCaseWithBzrDir):

    # Many of these tests test for disk equality rather than checking

    # for semantic equivalence. This works well for some tests but

    # is not good at handling changes in representation or the addition

    # or removal of control data. It would be nice to for instance:

    # sprout a new branch, check that the nickname has been reset by hand

    # and then set the nickname to match the source branch, at which point

    # a semantic equivalence should pass

    def assertDirectoriesEqual(self, source, target, ignore_list=[]):

        """Assert that the content of source and target are identical.

        paths in ignore list will be completely ignored.

        """

        files = []

        directories = ['.']

        while directories:

            dir = directories.pop()

            for path in source.list_dir(dir):

                path = dir + '/' + path

                if path in ignore_list:

                    continue

                stat = source.stat(path)

                if S_ISDIR(stat.st_mode):

                    self.assertTrue(S_ISDIR(target.stat(path).st_mode))

                    directories.append(path)

                else:

                    self.assertEqualDiff(source.get(path).read(),

                                         target.get(path).read(),

                                         "text for file %r differs:\n" % path)

    def test_clone_bzrdir_empty(self):

        dir = self.make_bzrdir('source')

        target = dir.clone(self.get_url('target'))

        self.assertNotEqual(dir.transport.base, target.transport.base)

        self.assertDirectoriesEqual(dir.root_transport, target.root_transport)

    def test_clone_bzrdir_empty_force_new_ignored(self):

        # the force_new_repo parameter should have no effect on an empty

        # bzrdir's clone logic

        dir = self.make_bzrdir('source')

        target = dir.clone(self.get_url('target'), force_new_repo=True)

        self.assertNotEqual(dir.transport.base, target.transport.base)

        self.assertDirectoriesEqual(dir.root_transport, target.root_transport)

    def test_clone_bzrdir_repository(self):

        tree = self.make_branch_and_tree('commit_tree')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1', rev_id='1')

        dir = self.make_bzrdir('source')

        repo = dir.create_repository()

        repo.fetch(tree.branch.repository)

        self.assertTrue(repo.has_revision('1'))

        target = dir.clone(self.get_url('target'))

        self.assertNotEqual(dir.transport.base, target.transport.base)

        self.assertDirectoriesEqual(dir.root_transport, target.root_transport)

    def test_clone_bzrdir_repository_under_shared(self):

        tree = self.make_branch_and_tree('commit_tree')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1', rev_id='1')

        dir = self.make_bzrdir('source')

        repo = dir.create_repository()

        repo.fetch(tree.branch.repository)

        self.assertTrue(repo.has_revision('1'))

        try:

            self.make_repository('target', shared=True)

        except errors.IncompatibleFormat:

            return

        target = dir.clone(self.get_url('target/child'))

        self.assertNotEqual(dir.transport.base, target.transport.base)

        self.assertRaises(errors.NoRepositoryPresent, target.open_repository)

    def test_clone_bzrdir_repository_branch_both_under_shared(self):

        try:

            shared_repo = self.make_repository('shared', shared=True)

        except errors.IncompatibleFormat:

            return

        tree = self.make_branch_and_tree('commit_tree')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1', rev_id='1')

        tree.bzrdir.open_branch().set_revision_history([])

        tree.set_last_revision(None)

        tree.commit('revision 2', rev_id='2')

        tree.bzrdir.open_repository().copy_content_into(shared_repo)

        dir = self.make_bzrdir('shared/source')

        dir.create_branch()

        target = dir.clone(self.get_url('shared/target'))

        self.assertNotEqual(dir.transport.base, target.transport.base)

        self.assertNotEqual(dir.transport.base, shared_repo.bzrdir.transport.base)

        self.assertTrue(shared_repo.has_revision('1'))

    def test_clone_bzrdir_repository_under_shared_force_new_repo(self):

        tree = self.make_branch_and_tree('commit_tree')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1', rev_id='1')

        dir = self.make_bzrdir('source')

        repo = dir.create_repository()

        repo.fetch(tree.branch.repository)

        self.assertTrue(repo.has_revision('1'))

        try:

            self.make_repository('target', shared=True)

        except errors.IncompatibleFormat:

            return

        target = dir.clone(self.get_url('target/child'), force_new_repo=True)

        self.assertNotEqual(dir.transport.base, target.transport.base)

        self.assertDirectoriesEqual(dir.root_transport, target.root_transport)

    def test_clone_bzrdir_repository_revision(self):

        # test for revision limiting, [smoke test, not corner case checks].

        # make a repository with some revisions,

        # and clone it with a revision limit.

        # 

        tree = self.make_branch_and_tree('commit_tree')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1', rev_id='1')

        tree.bzrdir.open_branch().set_revision_history([])

        tree.set_last_revision(None)

        tree.commit('revision 2', rev_id='2')

        source = self.make_repository('source')

        tree.bzrdir.open_repository().copy_content_into(source)

        dir = source.bzrdir

        target = dir.clone(self.get_url('target'), revision_id='2')

        raise TestSkipped('revision limiting not strict yet')

    def test_clone_bzrdir_branch_and_repo(self):

        tree = self.make_branch_and_tree('commit_tree')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1')

        source = self.make_branch('source')

        tree.bzrdir.open_repository().copy_content_into(source.repository)

        tree.bzrdir.open_branch().copy_content_into(source)

        dir = source.bzrdir

        target = dir.clone(self.get_url('target'))

        self.assertNotEqual(dir.transport.base, target.transport.base)

        self.assertDirectoriesEqual(dir.root_transport, target.root_transport,

                                    ['./.bzr/stat-cache', './.bzr/checkout/stat-cache'])

    def test_clone_bzrdir_branch_and_repo_into_shared_repo(self):

        # by default cloning into a shared repo uses the shared repo.

        tree = self.make_branch_and_tree('commit_tree')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1')

        source = self.make_branch('source')

        tree.bzrdir.open_repository().copy_content_into(source.repository)

        tree.bzrdir.open_branch().copy_content_into(source)

        try:

            self.make_repository('target', shared=True)

        except errors.IncompatibleFormat:

            return

        dir = source.bzrdir

        target = dir.clone(self.get_url('target/child'))

        self.assertNotEqual(dir.transport.base, target.transport.base)

        self.assertRaises(errors.NoRepositoryPresent, target.open_repository)

        self.assertEqual(source.revision_history(),

                         target.open_branch().revision_history())

    def test_clone_bzrdir_branch_and_repo_into_shared_repo_force_new_repo(self):

        # by default cloning into a shared repo uses the shared repo.

        tree = self.make_branch_and_tree('commit_tree')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1')

        source = self.make_branch('source')

        tree.bzrdir.open_repository().copy_content_into(source.repository)

        tree.bzrdir.open_branch().copy_content_into(source)

        try:

            self.make_repository('target', shared=True)

        except errors.IncompatibleFormat:

            return

        dir = source.bzrdir

        target = dir.clone(self.get_url('target/child'), force_new_repo=True)

        self.assertNotEqual(dir.transport.base, target.transport.base)

        target.open_repository()

        self.assertDirectoriesEqual(dir.root_transport, target.root_transport)

    def test_clone_bzrdir_branch_reference(self):

        # cloning should preserve the reference status of the branch in a bzrdir

        referenced_branch = self.make_branch('referencced')

        dir = self.make_bzrdir('source')

        try:

            reference = bzrlib.branch.BranchReferenceFormat().initialize(dir,

                referenced_branch)

        except errors.IncompatibleFormat:

            # this is ok too, not all formats have to support references.

            return

        target = dir.clone(self.get_url('target'))

        self.assertNotEqual(dir.transport.base, target.transport.base)

        self.assertDirectoriesEqual(dir.root_transport, target.root_transport)

    def test_clone_bzrdir_branch_revision(self):

        # test for revision limiting, [smoke test, not corner case checks].

        # make a branch with some revisions,

        # and clone it with a revision limit.

        # 

        tree = self.make_branch_and_tree('commit_tree')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1', rev_id='1')

        tree.commit('revision 2', rev_id='2', allow_pointless=True)

        source = self.make_branch('source')

        tree.bzrdir.open_repository().copy_content_into(source.repository)

        tree.bzrdir.open_branch().copy_content_into(source)

        dir = source.bzrdir

        target = dir.clone(self.get_url('target'), revision_id='1')

        self.assertEqual('1', target.open_branch().last_revision())

    def test_clone_bzrdir_tree_branch_repo(self):

        tree = self.make_branch_and_tree('sourcce')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1')

        dir = tree.bzrdir

        target = dir.clone(self.get_url('target'))

        self.assertNotEqual(dir.transport.base, target.transport.base)

        self.assertDirectoriesEqual(dir.root_transport, target.root_transport,

                                    ['./.bzr/stat-cache', './.bzr/checkout/stat-cache'])

        target.open_workingtree().revert([])

    def test_revert_inventory(self):

        tree = self.make_branch_and_tree('sourcce')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1')

        dir = tree.bzrdir

        target = dir.clone(self.get_url('target'))

        self.assertDirectoriesEqual(dir.root_transport, target.root_transport,

                                    ['./.bzr/stat-cache', './.bzr/checkout/stat-cache'])

        target.open_workingtree().revert([])

        self.assertDirectoriesEqual(dir.root_transport, target.root_transport,

                                    ['./.bzr/stat-cache', './.bzr/checkout/stat-cache'])

    def test_clone_bzrdir_tree_branch_reference(self):

        # a tree with a branch reference (aka a checkout) 

        # should stay a checkout on clone.

        referenced_branch = self.make_branch('referencced')

        dir = self.make_bzrdir('source')

        try:

            reference = bzrlib.branch.BranchReferenceFormat().initialize(dir,

                referenced_branch)

        except errors.IncompatibleFormat:

            # this is ok too, not all formats have to support references.

            return

        dir.create_workingtree()

        target = dir.clone(self.get_url('target'))

        self.assertNotEqual(dir.transport.base, target.transport.base)

        self.assertDirectoriesEqual(dir.root_transport, target.root_transport,

                                    ['./.bzr/stat-cache', './.bzr/checkout/stat-cache'])

    def test_clone_bzrdir_tree_revision(self):

        # test for revision limiting, [smoke test, not corner case checks].

        # make a tree with a revision with a last-revision

        # and clone it with a revision limit.

        # This smoke test just checks the revision-id is right. Tree specific

        # tests will check corner cases.

        tree = self.make_branch_and_tree('source')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1', rev_id='1')

        tree.commit('revision 2', rev_id='2', allow_pointless=True)

        dir = tree.bzrdir

        target = dir.clone(self.get_url('target'), revision_id='1')

        self.assertEqual('1', target.open_workingtree().last_revision())

    def test_clone_bzrdir_incomplete_source_with_basis(self):

        # ensure that basis really does grab from the basis by having incomplete source

        tree = self.make_branch_and_tree('commit_tree')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1', rev_id='1')

        source = self.make_branch_and_tree('source')

        # this gives us an incomplete repository

        tree.bzrdir.open_repository().copy_content_into(source.branch.repository)

        tree.commit('revision 2', rev_id='2', allow_pointless=True)

        tree.bzrdir.open_branch().copy_content_into(source.branch)

        tree.copy_content_into(source)

        self.assertFalse(source.branch.repository.has_revision('2'))

        dir = source.bzrdir

        target = dir.clone(self.get_url('target'), basis=tree.bzrdir)

        self.assertEqual('2', target.open_branch().last_revision())

        self.assertEqual('2', target.open_workingtree().last_revision())

        self.assertTrue(target.open_branch().repository.has_revision('2'))

    def test_sprout_bzrdir_empty(self):

        dir = self.make_bzrdir('source')

        target = dir.sprout(self.get_url('target'))

        self.assertNotEqual(dir.transport.base, target.transport.base)

        # creates a new repository branch and tree

        target.open_repository()

        target.open_branch()

        target.open_workingtree()

    def test_sprout_bzrdir_empty_under_shared_repo(self):

        # sprouting an empty dir into a repo uses the repo

        dir = self.make_bzrdir('source')

        try:

            self.make_repository('target', shared=True)

        except errors.IncompatibleFormat:

            return

        target = dir.sprout(self.get_url('target/child'))

        self.assertRaises(errors.NoRepositoryPresent, target.open_repository)

        target.open_branch()

        target.open_workingtree()

    def test_sprout_bzrdir_empty_under_shared_repo(self):

        # the force_new_repo parameter should force use of a new repo in an empty

        # bzrdir's sprout logic

        dir = self.make_bzrdir('source')

        try:

            self.make_repository('target', shared=True)

        except errors.IncompatibleFormat:

            return

        target = dir.sprout(self.get_url('target/child'), force_new_repo=True)

        target.open_repository()

        target.open_branch()

        target.open_workingtree()

    def test_sprout_bzrdir_repository(self):

        tree = self.make_branch_and_tree('commit_tree')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1', rev_id='1')

        dir = self.make_bzrdir('source')

        repo = dir.create_repository()

        repo.fetch(tree.branch.repository)

        self.assertTrue(repo.has_revision('1'))

        target = dir.sprout(self.get_url('target'))

        self.assertNotEqual(dir.transport.base, target.transport.base)

        self.assertDirectoriesEqual(dir.root_transport, target.root_transport)

    def test_sprout_bzrdir_with_repository_to_shared(self):

        tree = self.make_branch_and_tree('commit_tree')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1', rev_id='1')

        tree.bzrdir.open_branch().set_revision_history([])

        tree.set_last_revision(None)

        tree.commit('revision 2', rev_id='2')

        source = self.make_repository('source')

        tree.bzrdir.open_repository().copy_content_into(source)

        dir = source.bzrdir

        try:

            shared_repo = self.make_repository('target', shared=True)

        except errors.IncompatibleFormat:

            return

        target = dir.sprout(self.get_url('target/child'))

        self.assertNotEqual(dir.transport.base, target.transport.base)

        self.assertTrue(shared_repo.has_revision('1'))

    def test_sprout_bzrdir_repository_branch_both_under_shared(self):

        try:

            shared_repo = self.make_repository('shared', shared=True)

        except errors.IncompatibleFormat:

            return

        tree = self.make_branch_and_tree('commit_tree')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1', rev_id='1')

        tree.bzrdir.open_branch().set_revision_history([])

        tree.set_last_revision(None)

        tree.commit('revision 2', rev_id='2')

        tree.bzrdir.open_repository().copy_content_into(shared_repo)

        dir = self.make_bzrdir('shared/source')

        dir.create_branch()

        target = dir.sprout(self.get_url('shared/target'))

        self.assertNotEqual(dir.transport.base, target.transport.base)

        self.assertNotEqual(dir.transport.base, shared_repo.bzrdir.transport.base)

        self.assertTrue(shared_repo.has_revision('1'))

    def test_sprout_bzrdir_repository_under_shared_force_new_repo(self):

        tree = self.make_branch_and_tree('commit_tree')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1', rev_id='1')

        tree.bzrdir.open_branch().set_revision_history([])

        tree.set_last_revision(None)

        tree.commit('revision 2', rev_id='2')

        source = self.make_repository('source')

        tree.bzrdir.open_repository().copy_content_into(source)

        dir = source.bzrdir

        try:

            shared_repo = self.make_repository('target', shared=True)

        except errors.IncompatibleFormat:

            return

        target = dir.sprout(self.get_url('target/child'), force_new_repo=True)

        self.assertNotEqual(dir.transport.base, target.transport.base)

        self.assertFalse(shared_repo.has_revision('1'))

    def test_sprout_bzrdir_repository_revision(self):

        # test for revision limiting, [smoke test, not corner case checks].

        # make a repository with some revisions,

        # and sprout it with a revision limit.

        # 

        tree = self.make_branch_and_tree('commit_tree')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1', rev_id='1')

        tree.bzrdir.open_branch().set_revision_history([])

        tree.set_last_revision(None)

        tree.commit('revision 2', rev_id='2')

        source = self.make_repository('source')

        tree.bzrdir.open_repository().copy_content_into(source)

        dir = source.bzrdir

        target = dir.sprout(self.get_url('target'), revision_id='2')

        raise TestSkipped('revision limiting not strict yet')

    def test_sprout_bzrdir_branch_and_repo(self):

        tree = self.make_branch_and_tree('commit_tree')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1')

        source = self.make_branch('source')

        tree.bzrdir.open_repository().copy_content_into(source.repository)

        tree.bzrdir.open_branch().copy_content_into(source)

        dir = source.bzrdir

        target = dir.sprout(self.get_url('target'))

        self.assertNotEqual(dir.transport.base, target.transport.base)

        self.assertDirectoriesEqual(dir.root_transport, target.root_transport)

    def test_sprout_bzrdir_branch_and_repo_shared(self):

        # sprouting a branch with a repo into a shared repo uses the shared

        # repo

        tree = self.make_branch_and_tree('commit_tree')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1', rev_id='1')

        source = self.make_branch('source')

        tree.bzrdir.open_repository().copy_content_into(source.repository)

        tree.bzrdir.open_branch().copy_content_into(source)

        dir = source.bzrdir

        try:

            shared_repo = self.make_repository('target', shared=True)

        except errors.IncompatibleFormat:

            return

        target = dir.sprout(self.get_url('target/child'))

        self.assertTrue(shared_repo.has_revision('1'))

    def test_sprout_bzrdir_branch_and_repo_shared_force_new_repo(self):

        # sprouting a branch with a repo into a shared repo uses the shared

        # repo

        tree = self.make_branch_and_tree('commit_tree')

        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))

        tree.add('foo')

        tree.commit('revision 1', rev_id='1')

        source = self.make_branch('source')

        tree.bzrdir.open_repository().copy_content_into(source.repository)

        tree.bzrdir.open_branch().copy_content_into(source)

        dir = source.bzrdir

        try:

            shared_repo = self.make_repository('target', shared=True)

        except errors.IncompatibleFormat:

            return

        target = dir.sprout(self.get_url('target/child'), force_new_repo=True)

        self.assertNotEqual(dir.transport.base, target.transport.base)

        self.assertFalse(shared_repo.has_revision('1'))

    def test_sprout_bzrdir_branch_reference(self):

        # sprouting should create a repository if needed and a sprouted branch.

        referenced_branch = self.make_branch('referencced')

        dir = self.make_bzrdir('source')

        try:

            reference = bzrlib.branch.BranchReferenceFormat().initialize(dir,

                referenced_branch)

        except errors.IncompatibleFormat:

            # this is ok too, not all formats have to support references.

            return

        self.assertRaises(errors.NoRepositoryPresent, dir.open_repository)

        target = dir.sprout(self.get_url('target'))

        self.assertNotEqual(dir.transport.base, target.transport.base)

        # we want target to have a branch that is in-place.

        self.assertEqual(target, target.open_branch().bzrdir)

        # and as we dont support repositories being detached yet, a repo in 

        # place

        target.open_repository()

    def test_sprout_bzrdir_branch_reference_shared(self):

        # sprouting should create a repository if needed and a sprouted branch.

        referenced_tree = self.make_branch_and_tree('referenced')

        referenced_tree.commit('1', rev_id='1', allow_pointless=True)

        dir = self.make_bzrdir('source')

        try:

            reference = bzrlib.branch.BranchReferenceFormat().initialize(dir,

                referenced_tree.branch)

        except errors.IncompatibleFormat:

            # this is ok too, not all formats have to support references.

            return

        self.assertRaises(errors.NoRepositoryPresent, dir.open_repository)

        try:

            shared_repo = self.make_repository('target', shared=True)

        except errors.IncompatibleFormat:

            return

        target = dir.sprout(self.get_url('target/child'))

        self.assertNotEqual(dir.transport.base, target.transport.base)

        # we want target to have a branch that is in-place.

        self.assertEqual(target, target.open_branch().bzrdir)

        # and we want no repository as the target is shared

        self.assertRaises(errors.NoRepositoryPresent, 

                          target.open_repository)

        # and we want revision '1' in the shared repo

        self.assertTrue(shared_repo.has_revision('1'))

    def test_sprout_bzrdir_branch_reference_shared_force_new_repo(self):

        # sprouting should create a repository if needed and a sprouted branch.

        referenced_tree = self.make_branch_and_tree('referenced')

        referenced_tree.commit('1', rev_id='1', allow_pointless=True)

        dir = self.make_bzrdir('source')

        try:

            reference = bzrlib.branch.BranchReferenceFormat().initialize(dir,

                referenced_tree.branch)

        except errors.IncompatibleFormat:

            # this is ok too, not all formats have to support references.

            return

        self.assertRaises(errors.NoRepositoryPresent, dir.open_repository)