← 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: Vincent Ladeuil
  • Date: 2016-01-21 11:42:23 UTC
  • mto: This revision was merged to the branch mainline in revision 6610.
  • Revision ID: v.ladeuil+lp@free.fr-20160121114223-ngcvndi02ydiqs5z
Allow hyphens in option names to unbreak compatibility.

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
 
 
22
from bzrlib import errors
21
23
from bzrlib import (
22
24
    lazy_regex,
23
25
    tests,
40
42
    def _real_re_compile(self, *args, **kwargs):
41
43
        self._actions.append(('_real_re_compile',
42
44
                                               args, kwargs))
43
 
        return super(InstrumentedLazyRegex, self)._real_re_compile(*args, **kwargs)
 
45
        return super(InstrumentedLazyRegex, self)._real_re_compile(
 
46
            *args, **kwargs)
44
47
 
45
48
 
46
49
class TestLazyRegex(tests.TestCase):
63
66
                          ('_real_re_compile', ('foo',), {}),
64
67
                         ], actions)
65
68
 
 
69
    def test_bad_pattern(self):
 
70
        """Ensure lazy regex handles bad patterns cleanly."""
 
71
        p = lazy_regex.lazy_compile('RE:[')
 
72
        # As p.match is lazy, we make it into a lambda so its handled
 
73
        # by assertRaises correctly.
 
74
        e = self.assertRaises(errors.InvalidPattern, lambda: p.match('foo'))
 
75
        self.assertEqual(e.msg, '"RE:[" unexpected end of regular expression')
 
76
 
66
77
 
67
78
class TestLazyCompile(tests.TestCase):
68
79
 
105
116
        pattern = lazy_regex.lazy_compile('[,;]*')
106
117
        self.assertEqual(['x', 'y', 'z'], pattern.split('x,y;z'))
107
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
 
108
129
 
109
130
class TestInstallLazyCompile(tests.TestCase):
 
131
    """Tests for lazy compiled regexps.
110
132
 
111
 
    def setUp(self):
112
 
        super(TestInstallLazyCompile, self).setUp()
113
 
        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
    """
114
137
 
115
138
    def test_install(self):
 
139
        # Don't count on it being present
116
140
        lazy_regex.install_lazy_compile()
117
141
        pattern = re.compile('foo')
118
142
        self.assertIsInstance(pattern, lazy_regex.LazyRegex)
119
143
 
120
144
    def test_reset(self):
121
 
        lazy_regex.install_lazy_compile()
122
145
        lazy_regex.reset_compile()
 
146
        self.addCleanup(lazy_regex.install_lazy_compile)
123
147
        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),))
 
148
        self.assertFalse(isinstance(pattern, lazy_regex.LazyRegex),
 
149
            'lazy_regex.reset_compile() did not restore the original'
 
150
            ' compile() function %s' % (type(pattern),))
127
151
        # but the returned object should still support regex operations
128
152
        m = pattern.match('foo')
129
153
        self.assertEqual('foo', m.group())