← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_lazy_regex.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-08-17 18:13:57 UTC
  • mfrom: (5268.7.29 transport-segments)
  • Revision ID: pqm@pqm.ubuntu.com-20110817181357-y5q5eth1hk8bl3om
(jelmer) Allow specifying the colocated branch to use in the branch URL,
 and retrieving the branch name using ControlDir._get_selected_branch.
 (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_lazy_regex.py
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2006, 2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Test that lazy regexes are not compiled right away"""
18
18
 
19
19
import re
20
20
 
 
21
from bzrlib import errors
21
22
from bzrlib import (
22
23
    lazy_regex,
23
24
    tests,
40
41
    def _real_re_compile(self, *args, **kwargs):
41
42
        self._actions.append(('_real_re_compile',
42
43
                                               args, kwargs))
43
 
        return super(InstrumentedLazyRegex, self)._real_re_compile(*args, **kwargs)
 
44
        return super(InstrumentedLazyRegex, self)._real_re_compile(
 
45
            *args, **kwargs)
44
46
 
45
47
 
46
48
class TestLazyRegex(tests.TestCase):
63
65
                          ('_real_re_compile', ('foo',), {}),
64
66
                         ], actions)
65
67
 
 
68
    def test_bad_pattern(self):
 
69
        """Ensure lazy regex handles bad patterns cleanly."""
 
70
        p = lazy_regex.lazy_compile('RE:[')
 
71
        # As p.match is lazy, we make it into a lambda so its handled
 
72
        # by assertRaises correctly.
 
73
        e = self.assertRaises(errors.InvalidPattern, lambda: p.match('foo'))
 
74
        self.assertEqual(e.msg, '"RE:[" unexpected end of regular expression')
 
75
 
66
76
 
67
77
class TestLazyCompile(tests.TestCase):
68
78
 
107
117
 
108
118
 
109
119
class TestInstallLazyCompile(tests.TestCase):
 
120
    """Tests for lazy compiled regexps.
110
121
 
111
 
    def setUp(self):
112
 
        super(TestInstallLazyCompile, self).setUp()
113
 
        self.addCleanup(lazy_regex.reset_compile)
 
122
    Other tests, and bzrlib in general, count on the lazy regexp compiler
 
123
    being installed, and this is done by loading bzrlib.  So these tests
 
124
    assume it is installed, and leave it installed when they're done.
 
125
    """
114
126
 
115
127
    def test_install(self):
 
128
        # Don't count on it being present
116
129
        lazy_regex.install_lazy_compile()
117
130
        pattern = re.compile('foo')
118
131
        self.assertIsInstance(pattern, lazy_regex.LazyRegex)
119
132
 
120
133
    def test_reset(self):
121
 
        lazy_regex.install_lazy_compile()
122
134
        lazy_regex.reset_compile()
 
135
        self.addCleanup(lazy_regex.install_lazy_compile)
123
136
        pattern = re.compile('foo')
124
 
        self.failIf(isinstance(pattern, lazy_regex.LazyRegex),
125
 
                    'lazy_regex.reset_compile() did not restore the original'
126
 
                    ' compile() function %s' % (type(pattern),))
 
137
        self.assertFalse(isinstance(pattern, lazy_regex.LazyRegex),
 
138
            'lazy_regex.reset_compile() did not restore the original'
 
139
            ' compile() function %s' % (type(pattern),))
127
140
        # but the returned object should still support regex operations
128
141
        m = pattern.match('foo')
129
142
        self.assertEqual('foo', m.group())