← 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: Patch Queue Manager
  • Date: 2015-09-30 16:43:21 UTC
  • mfrom: (6603.2.2 fix-keep-dirty)
  • Revision ID: pqm@pqm.ubuntu.com-20150930164321-ct2v2qnmvimqt8qf
(vila) Avoid associating dirty patch headers with the previous file in the
 patch. (Colin Watson)

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
16
16
 
17
17
"""Test that lazy regexes are not compiled right away"""
18
18
 
 
19
import pickle
19
20
import re
20
21
 
21
22
from bzrlib import errors
41
42
    def _real_re_compile(self, *args, **kwargs):
42
43
        self._actions.append(('_real_re_compile',
43
44
                                               args, kwargs))
44
 
        return super(InstrumentedLazyRegex, self)._real_re_compile(*args, **kwargs)
 
45
        return super(InstrumentedLazyRegex, self)._real_re_compile(
 
46
            *args, **kwargs)
45
47
 
46
48
 
47
49
class TestLazyRegex(tests.TestCase):
114
116
        pattern = lazy_regex.lazy_compile('[,;]*')
115
117
        self.assertEqual(['x', 'y', 'z'], pattern.split('x,y;z'))
116
118
 
 
119
    def test_pickle(self):
 
120
        # When pickling, just compile the regex.
 
121
        # Sphinx, which we use for documentation, pickles
 
122
        # some compiled regexes.
 
123
        lazy_pattern = lazy_regex.lazy_compile('[,;]*')
 
124
        pickled = pickle.dumps(lazy_pattern)
 
125
        unpickled_lazy_pattern = pickle.loads(pickled)
 
126
        self.assertEqual(['x', 'y', 'z'],
 
127
            unpickled_lazy_pattern.split('x,y;z'))
 
128
 
117
129
 
118
130
class TestInstallLazyCompile(tests.TestCase):
 
131
    """Tests for lazy compiled regexps.
119
132
 
120
 
    def setUp(self):
121
 
        super(TestInstallLazyCompile, self).setUp()
122
 
        self.addCleanup(lazy_regex.reset_compile)
 
133
    Other tests, and bzrlib in general, count on the lazy regexp compiler
 
134
    being installed, and this is done by loading bzrlib.  So these tests
 
135
    assume it is installed, and leave it installed when they're done.
 
136
    """
123
137
 
124
138
    def test_install(self):
 
139
        # Don't count on it being present
125
140
        lazy_regex.install_lazy_compile()
126
141
        pattern = re.compile('foo')
127
142
        self.assertIsInstance(pattern, lazy_regex.LazyRegex)
128
143
 
129
144
    def test_reset(self):
130
 
        lazy_regex.install_lazy_compile()
131
145
        lazy_regex.reset_compile()
 
146
        self.addCleanup(lazy_regex.install_lazy_compile)
132
147
        pattern = re.compile('foo')
133
 
        self.failIf(isinstance(pattern, lazy_regex.LazyRegex),
134
 
                    'lazy_regex.reset_compile() did not restore the original'
135
 
                    ' compile() function %s' % (type(pattern),))
 
148
        self.assertFalse(isinstance(pattern, lazy_regex.LazyRegex),
 
149
            'lazy_regex.reset_compile() did not restore the original'
 
150
            ' compile() function %s' % (type(pattern),))
136
151
        # but the returned object should still support regex operations
137
152
        m = pattern.match('foo')
138
153
        self.assertEqual('foo', m.group())