/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 breezy/tests/test_lazy_regex.py

  • Committer: Jelmer Vernooij
  • Date: 2018-11-16 18:15:40 UTC
  • mto: (7143.16.20 even-more-cleanups)
  • mto: This revision was merged to the branch mainline in revision 7175.
  • Revision ID: jelmer@jelmer.uk-20181116181540-7y2wbhqzjk067mqy
Fix repo acquisition.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/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
 
from bzrlib import (
 
22
from .. import errors
 
23
from .. import (
22
24
    lazy_regex,
23
25
    tests,
24
26
    )
25
27
 
26
28
 
 
29
class TestErrors(tests.TestCase):
 
30
 
 
31
    def test_invalid_pattern(self):
 
32
        error = lazy_regex.InvalidPattern('Bad pattern msg.')
 
33
        self.assertEqualDiff("Invalid pattern(s) found. Bad pattern msg.",
 
34
                             str(error))
 
35
 
 
36
 
27
37
class InstrumentedLazyRegex(lazy_regex.LazyRegex):
28
38
    """Keep track of actions on the lazy regex"""
29
39
 
39
49
 
40
50
    def _real_re_compile(self, *args, **kwargs):
41
51
        self._actions.append(('_real_re_compile',
42
 
                                               args, kwargs))
43
 
        return super(InstrumentedLazyRegex, self)._real_re_compile(*args, **kwargs)
 
52
                              args, kwargs))
 
53
        return super(InstrumentedLazyRegex, self)._real_re_compile(
 
54
            *args, **kwargs)
44
55
 
45
56
 
46
57
class TestLazyRegex(tests.TestCase):
61
72
        self.assertEqual([('created regex', 'foo'),
62
73
                          ('__getattr__', 'match'),
63
74
                          ('_real_re_compile', ('foo',), {}),
64
 
                         ], actions)
 
75
                          ], actions)
 
76
 
 
77
    def test_bad_pattern(self):
 
78
        """Ensure lazy regex handles bad patterns cleanly."""
 
79
        p = lazy_regex.lazy_compile('RE:[')
 
80
        # As p.match is lazy, we make it into a lambda so its handled
 
81
        # by assertRaises correctly.
 
82
        e = self.assertRaises(lazy_regex.InvalidPattern,
 
83
                              lambda: p.match('foo'))
 
84
        # Expect either old or new form of error message
 
85
        self.assertContainsRe(e.msg, '^"RE:\\[" '
 
86
                              '(unexpected end of regular expression'
 
87
                              '|unterminated character set at position 3)$')
65
88
 
66
89
 
67
90
class TestLazyCompile(tests.TestCase):
102
125
        self.assertEqual('fooo', pattern.search('fooo').group())
103
126
 
104
127
    def test_split(self):
105
 
        pattern = lazy_regex.lazy_compile('[,;]*')
 
128
        pattern = lazy_regex.lazy_compile('[,;]+')
106
129
        self.assertEqual(['x', 'y', 'z'], pattern.split('x,y;z'))
107
130
 
 
131
    def test_pickle(self):
 
132
        # When pickling, just compile the regex.
 
133
        # Sphinx, which we use for documentation, pickles
 
134
        # some compiled regexes.
 
135
        lazy_pattern = lazy_regex.lazy_compile('[,;]+')
 
136
        pickled = pickle.dumps(lazy_pattern)
 
137
        unpickled_lazy_pattern = pickle.loads(pickled)
 
138
        self.assertEqual(['x', 'y', 'z'],
 
139
                         unpickled_lazy_pattern.split('x,y;z'))
 
140
 
108
141
 
109
142
class TestInstallLazyCompile(tests.TestCase):
 
143
    """Tests for lazy compiled regexps.
110
144
 
111
 
    def setUp(self):
112
 
        super(TestInstallLazyCompile, self).setUp()
113
 
        self.addCleanup(lazy_regex.reset_compile)
 
145
    Other tests, and breezy in general, count on the lazy regexp compiler
 
146
    being installed, and this is done by loading breezy.  So these tests
 
147
    assume it is installed, and leave it installed when they're done.
 
148
    """
114
149
 
115
150
    def test_install(self):
 
151
        # Don't count on it being present
116
152
        lazy_regex.install_lazy_compile()
117
153
        pattern = re.compile('foo')
118
154
        self.assertIsInstance(pattern, lazy_regex.LazyRegex)
119
155
 
120
156
    def test_reset(self):
121
 
        lazy_regex.install_lazy_compile()
122
157
        lazy_regex.reset_compile()
 
158
        self.addCleanup(lazy_regex.install_lazy_compile)
123
159
        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),))
 
160
        self.assertFalse(isinstance(pattern, lazy_regex.LazyRegex),
 
161
                         'lazy_regex.reset_compile() did not restore the original'
 
162
                         ' compile() function %s' % (type(pattern),))
127
163
        # but the returned object should still support regex operations
128
164
        m = pattern.match('foo')
129
165
        self.assertEqual('foo', m.group())