← 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: John Arbash Meinel
  • Date: 2009-06-02 19:56:24 UTC
  • mto: This revision was merged to the branch mainline in revision 4469.
  • Revision ID: john@arbash-meinel.com-20090602195624-utljsyz0qgmq63lg
Add a chunks_to_gzip function.
This allows the _record_to_data code to build up a list of chunks,
rather than requiring a single string.
It should be ~ the same performance when using a single string, since
we are only adding a for() loop over the chunks and an if check.
We could possibly just remove the if check and not worry about adding
some empty strings in there.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_lazy_regex.py
1
 
# Copyright (C) 2006, 2011 Canonical Ltd
 
1
# Copyright (C) 2006 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
18
18
 
19
19
import re
20
20
 
21
 
from bzrlib import errors
22
21
from bzrlib import (
23
22
    lazy_regex,
24
23
    tests,
41
40
    def _real_re_compile(self, *args, **kwargs):
42
41
        self._actions.append(('_real_re_compile',
43
42
                                               args, kwargs))
44
 
        return super(InstrumentedLazyRegex, self)._real_re_compile(
45
 
            *args, **kwargs)
 
43
        return super(InstrumentedLazyRegex, self)._real_re_compile(*args, **kwargs)
46
44
 
47
45
 
48
46
class TestLazyRegex(tests.TestCase):
65
63
                          ('_real_re_compile', ('foo',), {}),
66
64
                         ], actions)
67
65
 
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
 
 
76
66
 
77
67
class TestLazyCompile(tests.TestCase):
78
68
 
117
107
 
118
108
 
119
109
class TestInstallLazyCompile(tests.TestCase):
120
 
    """Tests for lazy compiled regexps.
121
110
 
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
 
    """
 
111
    def setUp(self):
 
112
        super(TestInstallLazyCompile, self).setUp()
 
113
        self.addCleanup(lazy_regex.reset_compile)
126
114
 
127
115
    def test_install(self):
128
 
        # Don't count on it being present
129
116
        lazy_regex.install_lazy_compile()
130
117
        pattern = re.compile('foo')
131
118
        self.assertIsInstance(pattern, lazy_regex.LazyRegex)
132
119
 
133
120
    def test_reset(self):
 
121
        lazy_regex.install_lazy_compile()
134
122
        lazy_regex.reset_compile()
135
 
        self.addCleanup(lazy_regex.install_lazy_compile)
136
123
        pattern = re.compile('foo')
137
 
        self.assertFalse(isinstance(pattern, lazy_regex.LazyRegex),
138
 
            'lazy_regex.reset_compile() did not restore the original'
139
 
            ' compile() function %s' % (type(pattern),))
 
124
        self.failIf(isinstance(pattern, lazy_regex.LazyRegex),
 
125
                    'lazy_regex.reset_compile() did not restore the original'
 
126
                    ' compile() function %s' % (type(pattern),))
140
127
        # but the returned object should still support regex operations
141
128
        m = pattern.match('foo')
142
129
        self.assertEqual('foo', m.group())