/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/__init__.py

  • Committer: John Arbash Meinel
  • Date: 2010-08-02 17:16:12 UTC
  • mto: This revision was merged to the branch mainline in revision 5369.
  • Revision ID: john@arbash-meinel.com-20100802171612-rdh5ods70w2bl3j7
We also have to re-implement it for _simple_set_pyx.pyx

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/__init__.py
29
29
 
30
30
import atexit
31
31
import codecs
32
 
from copy import copy
 
32
import copy
33
33
from cStringIO import StringIO
34
34
import difflib
35
35
import doctest
37
37
import logging
38
38
import math
39
39
import os
40
 
from pprint import pformat
 
40
import pprint
41
41
import random
42
42
import re
43
43
import shlex
44
44
import stat
45
 
from subprocess import Popen, PIPE, STDOUT
 
45
import subprocess
46
46
import sys
47
47
import tempfile
48
48
import threading
74
74
    ui,
75
75
    urlutils,
76
76
    registry,
 
77
    transport as _mod_transport,
77
78
    workingtree,
78
79
    )
79
80
import bzrlib.branch
103
104
    )
104
105
import bzrlib.trace
105
106
from bzrlib.transport import (
106
 
    get_transport,
107
107
    memory,
108
108
    pathfilter,
109
109
    )
110
 
import bzrlib.transport
111
110
from bzrlib.trace import mutter, note
112
111
from bzrlib.tests import (
113
112
    test_server,
749
748
    # XXX: Should probably unify more with CannedInputUIFactory or a
750
749
    # particular configuration of TextUIFactory, or otherwise have a clearer
751
750
    # idea of how they're supposed to be different.
752
 
    # See https://bugs.edge.launchpad.net/bzr/+bug/408213
 
751
    # See https://bugs.launchpad.net/bzr/+bug/408213
753
752
 
754
753
    def __init__(self, stdout=None, stderr=None, stdin=None):
755
754
        if stdin is not None:
943
942
 
944
943
    def permit_dir(self, name):
945
944
        """Permit a directory to be used by this test. See permit_url."""
946
 
        name_transport = get_transport(name)
 
945
        name_transport = _mod_transport.get_transport(name)
947
946
        self.permit_url(name)
948
947
        self.permit_url(name_transport.base)
949
948
 
1028
1027
        self.addCleanup(transport_server.stop_server)
1029
1028
        # Obtain a real transport because if the server supplies a password, it
1030
1029
        # will be hidden from the base on the client side.
1031
 
        t = get_transport(transport_server.get_url())
 
1030
        t = _mod_transport.get_transport(transport_server.get_url())
1032
1031
        # Some transport servers effectively chroot the backing transport;
1033
1032
        # others like SFTPServer don't - users of the transport can walk up the
1034
1033
        # transport to read the entire backing transport. This wouldn't matter
1095
1094
            message += '\n'
1096
1095
        raise AssertionError("%snot equal:\na = %s\nb = %s\n"
1097
1096
            % (message,
1098
 
               pformat(a), pformat(b)))
 
1097
               pprint.pformat(a), pprint.pformat(b)))
1099
1098
 
1100
1099
    assertEquals = assertEqual
1101
1100
 
1986
1985
            if not allow_plugins:
1987
1986
                command.append('--no-plugins')
1988
1987
            command.extend(process_args)
1989
 
            process = self._popen(command, stdin=PIPE, stdout=PIPE, stderr=PIPE)
 
1988
            process = self._popen(command, stdin=subprocess.PIPE,
 
1989
                                  stdout=subprocess.PIPE,
 
1990
                                  stderr=subprocess.PIPE)
1990
1991
        finally:
1991
1992
            restore_environment()
1992
1993
            if cwd is not None:
2000
2001
        Allows tests to override this method to intercept the calls made to
2001
2002
        Popen for introspection.
2002
2003
        """
2003
 
        return Popen(*args, **kwargs)
 
2004
        return subprocess.Popen(*args, **kwargs)
2004
2005
 
2005
2006
    def get_source_path(self):
2006
2007
        """Return the path of the directory containing bzrlib."""
2008
2009
 
2009
2010
    def get_bzr_path(self):
2010
2011
        """Return the path of the 'bzr' executable for this test suite."""
2011
 
        bzr_path = self.get_source_path()+'/bzr'
 
2012
        bzr_path = os.path.join(self.get_source_path(), "bzr")
2012
2013
        if not os.path.isfile(bzr_path):
2013
2014
            # We are probably installed. Assume sys.argv is the right file
2014
2015
            bzr_path = sys.argv[0]
2186
2187
 
2187
2188
        :param relpath: a path relative to the base url.
2188
2189
        """
2189
 
        t = get_transport(self.get_url(relpath))
 
2190
        t = _mod_transport.get_transport(self.get_url(relpath))
2190
2191
        self.assertFalse(t.is_readonly())
2191
2192
        return t
2192
2193
 
2198
2199
 
2199
2200
        :param relpath: a path relative to the base url.
2200
2201
        """
2201
 
        t = get_transport(self.get_readonly_url(relpath))
 
2202
        t = _mod_transport.get_transport(self.get_readonly_url(relpath))
2202
2203
        self.assertTrue(t.is_readonly())
2203
2204
        return t
2204
2205
 
2334
2335
        propagating. This method ensures than a test did not leaked.
2335
2336
        """
2336
2337
        root = TestCaseWithMemoryTransport.TEST_ROOT
2337
 
        self.permit_url(get_transport(root).base)
 
2338
        self.permit_url(_mod_transport.get_transport(root).base)
2338
2339
        wt = workingtree.WorkingTree.open(root)
2339
2340
        last_rev = wt.last_revision()
2340
2341
        if last_rev != 'null:':
2385
2386
            # might be a relative or absolute path
2386
2387
            maybe_a_url = self.get_url(relpath)
2387
2388
            segments = maybe_a_url.rsplit('/', 1)
2388
 
            t = get_transport(maybe_a_url)
 
2389
            t = _mod_transport.get_transport(maybe_a_url)
2389
2390
            if len(segments) > 1 and segments[-1] not in ('', '.'):
2390
2391
                t.ensure_base()
2391
2392
            if format is None:
2408
2409
        made_control = self.make_bzrdir(relpath, format=format)
2409
2410
        return made_control.create_repository(shared=shared)
2410
2411
 
2411
 
    def make_smart_server(self, path):
 
2412
    def make_smart_server(self, path, backing_server=None):
 
2413
        if backing_server is None:
 
2414
            backing_server = self.get_server()
2412
2415
        smart_server = test_server.SmartTCPServer_for_testing()
2413
 
        self.start_server(smart_server, self.get_server())
2414
 
        remote_transport = get_transport(smart_server.get_url()).clone(path)
 
2416
        self.start_server(smart_server, backing_server)
 
2417
        remote_transport = _mod_transport.get_transport(smart_server.get_url()
 
2418
                                                   ).clone(path)
2415
2419
        return remote_transport
2416
2420
 
2417
2421
    def make_branch_and_memory_tree(self, relpath, format=None):
2482
2486
 
2483
2487
    def check_file_contents(self, filename, expect):
2484
2488
        self.log("check contents of file %s" % filename)
2485
 
        contents = file(filename, 'r').read()
 
2489
        f = file(filename)
 
2490
        try:
 
2491
            contents = f.read()
 
2492
        finally:
 
2493
            f.close()
2486
2494
        if contents != expect:
2487
2495
            self.log("expected: %r" % expect)
2488
2496
            self.log("actually: %r" % contents)
2562
2570
                "a list or a tuple. Got %r instead" % (shape,))
2563
2571
        # It's OK to just create them using forward slashes on windows.
2564
2572
        if transport is None or transport.is_readonly():
2565
 
            transport = get_transport(".")
 
2573
            transport = _mod_transport.get_transport(".")
2566
2574
        for name in shape:
2567
2575
            self.assertIsInstance(name, basestring)
2568
2576
            if name[-1] == '/':
2736
2744
    :param pattern: A regular expression string.
2737
2745
    :return: A callable that returns True if the re matches.
2738
2746
    """
2739
 
    filter_re = osutils.re_compile_checked(pattern, 0,
2740
 
        'test filter')
 
2747
    filter_re = re.compile(pattern, 0)
2741
2748
    def condition(test):
2742
2749
        test_id = test.id()
2743
2750
        return filter_re.search(test_id)
3309
3316
                '--subunit']
3310
3317
            if '--no-plugins' in sys.argv:
3311
3318
                argv.append('--no-plugins')
3312
 
            # stderr=STDOUT would be ideal, but until we prevent noise on
3313
 
            # stderr it can interrupt the subunit protocol.
3314
 
            process = Popen(argv, stdin=PIPE, stdout=PIPE, stderr=PIPE,
3315
 
                bufsize=1)
 
3319
            # stderr=subprocess.STDOUT would be ideal, but until we prevent
 
3320
            # noise on stderr it can interrupt the subunit protocol.
 
3321
            process = subprocess.Popen(argv, stdin=subprocess.PIPE,
 
3322
                                      stdout=subprocess.PIPE,
 
3323
                                      stderr=subprocess.PIPE,
 
3324
                                      bufsize=1)
3316
3325
            test = TestInSubprocess(process, test_list_file_name)
3317
3326
            result.append(test)
3318
3327
        except:
3367
3376
 
3368
3377
    def startTest(self, test):
3369
3378
        self.profiler = bzrlib.lsprof.BzrProfiler()
 
3379
        # Prevent deadlocks in tests that use lsprof: those tests will
 
3380
        # unavoidably fail.
 
3381
        bzrlib.lsprof.BzrProfiler.profiler_block = 0
3370
3382
        self.profiler.start()
3371
3383
        ForwardingResult.startTest(self, test)
3372
3384
 
3631
3643
        'bzrlib.doc',
3632
3644
        'bzrlib.tests.blackbox',
3633
3645
        'bzrlib.tests.commands',
 
3646
        'bzrlib.tests.doc_generate',
3634
3647
        'bzrlib.tests.per_branch',
3635
3648
        'bzrlib.tests.per_bzrdir',
3636
3649
        'bzrlib.tests.per_bzrdir_colo',
3700
3713
        'bzrlib.tests.test_export',
3701
3714
        'bzrlib.tests.test_extract',
3702
3715
        'bzrlib.tests.test_fetch',
 
3716
        'bzrlib.tests.test_fixtures',
3703
3717
        'bzrlib.tests.test_fifo_cache',
3704
3718
        'bzrlib.tests.test_filters',
3705
3719
        'bzrlib.tests.test_ftp_transport',
3726
3740
        'bzrlib.tests.test_knit',
3727
3741
        'bzrlib.tests.test_lazy_import',
3728
3742
        'bzrlib.tests.test_lazy_regex',
 
3743
        'bzrlib.tests.test_library_state',
3729
3744
        'bzrlib.tests.test_lock',
3730
3745
        'bzrlib.tests.test_lockable_files',
3731
3746
        'bzrlib.tests.test_lockdir',
3799
3814
        'bzrlib.tests.test_transport_log',
3800
3815
        'bzrlib.tests.test_tree',
3801
3816
        'bzrlib.tests.test_treebuilder',
 
3817
        'bzrlib.tests.test_treeshape',
3802
3818
        'bzrlib.tests.test_tsort',
3803
3819
        'bzrlib.tests.test_tuned_gzip',
3804
3820
        'bzrlib.tests.test_ui',
3835
3851
        'bzrlib.option',
3836
3852
        'bzrlib.symbol_versioning',
3837
3853
        'bzrlib.tests',
 
3854
        'bzrlib.tests.fixtures',
3838
3855
        'bzrlib.timestamp',
3839
3856
        'bzrlib.version_info_formats.format_custom',
3840
3857
        ]
4034
4051
    :param new_id: The id to assign to it.
4035
4052
    :return: The new test.
4036
4053
    """
4037
 
    new_test = copy(test)
 
4054
    new_test = copy.copy(test)
4038
4055
    new_test.id = lambda: new_id
4039
4056
    return new_test
4040
4057
 
4101
4118
        if test_id != None:
4102
4119
            ui.ui_factory.clear_term()
4103
4120
            sys.stderr.write('\nWhile running: %s\n' % (test_id,))
 
4121
        # Ugly, but the last thing we want here is fail, so bear with it.
 
4122
        printable_e = str(e).decode(osutils.get_user_encoding(), 'replace'
 
4123
                                    ).encode('ascii', 'replace')
4104
4124
        sys.stderr.write('Unable to remove testing dir %s\n%s'
4105
 
                         % (os.path.basename(dirname), e))
 
4125
                         % (os.path.basename(dirname), printable_e))
4106
4126
 
4107
4127
 
4108
4128
class Feature(object):
4338
4358
UnicodeFilename = _UnicodeFilename()
4339
4359
 
4340
4360
 
 
4361
class _ByteStringNamedFilesystem(Feature):
 
4362
    """Is the filesystem based on bytes?"""
 
4363
 
 
4364
    def _probe(self):
 
4365
        if os.name == "posix":
 
4366
            return True
 
4367
        return False
 
4368
 
 
4369
ByteStringNamedFilesystem = _ByteStringNamedFilesystem()
 
4370
 
 
4371
 
4341
4372
class _UTF8Filesystem(Feature):
4342
4373
    """Is the filesystem UTF-8?"""
4343
4374