~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test__dirstate_helpers.py

  • Committer: Danny van Heumen
  • Date: 2010-03-09 21:42:11 UTC
  • mto: (4634.139.5 2.0)
  • mto: This revision was merged to the branch mainline in revision 5160.
  • Revision ID: danny@dannyvanheumen.nl-20100309214211-iqh42x6qcikgd9p3
Reverted now-useless TODO list.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2007, 2008, 2009 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""Tests for the compiled dirstate helpers."""
 
18
 
 
19
import bisect
 
20
import os
 
21
import time
 
22
 
 
23
from bzrlib import (
 
24
    dirstate,
 
25
    errors,
 
26
    osutils,
 
27
    tests,
 
28
    )
 
29
from bzrlib.tests import (
 
30
    test_dirstate,
 
31
    test_osutils,
 
32
    )
 
33
 
 
34
try:
 
35
    from bzrlib import _dirstate_helpers_pyx
 
36
    has_dirstate_helpers_pyx = True
 
37
except ImportError:
 
38
    has_dirstate_helpers_pyx = False
 
39
 
 
40
 
 
41
class _CompiledDirstateHelpersFeature(tests.Feature):
 
42
    def _probe(self):
 
43
        return has_dirstate_helpers_pyx
 
44
 
 
45
    def feature_name(self):
 
46
        return 'bzrlib._dirstate_helpers_pyx'
 
47
CompiledDirstateHelpersFeature = _CompiledDirstateHelpersFeature()
 
48
 
 
49
 
 
50
def load_tests(basic_tests, module, loader):
 
51
    # FIXME: we should also parametrize against SHA1Provider !
 
52
    suite = loader.suiteClass()
 
53
    remaining_tests = basic_tests
 
54
 
 
55
    dir_reader_scenarios = test_osutils.dir_reader_scenarios()
 
56
 
 
57
    ue_scenarios = [('dirstate_Python',
 
58
                     {'update_entry': dirstate.py_update_entry})]
 
59
    if has_dirstate_helpers_pyx:
 
60
        pyrex_scenario = ('dirstate_Pyrex',
 
61
                          {'update_entry': _dirstate_helpers_pyx.update_entry})
 
62
        ue_scenarios.append(pyrex_scenario)
 
63
    process_entry_tests, remaining_tests = tests.split_suite_by_condition(
 
64
        remaining_tests, tests.condition_isinstance(TestUpdateEntry))
 
65
    tests.multiply_tests(process_entry_tests,
 
66
                         tests.multiply_scenarios(dir_reader_scenarios,
 
67
                                                  ue_scenarios),
 
68
                         suite)
 
69
 
 
70
    pe_scenarios = [('dirstate_Python',
 
71
                     {'_process_entry': dirstate.ProcessEntryPython})]
 
72
    if has_dirstate_helpers_pyx:
 
73
        pyrex_scenario = (
 
74
            'dirstate_Pyrex',
 
75
            {'_process_entry': _dirstate_helpers_pyx.ProcessEntryC})
 
76
        pe_scenarios.append(pyrex_scenario)
 
77
    process_entry_tests, remaining_tests = tests.split_suite_by_condition(
 
78
        remaining_tests, tests.condition_isinstance(TestProcessEntry))
 
79
    tests.multiply_tests(process_entry_tests,
 
80
                         tests.multiply_scenarios(dir_reader_scenarios,
 
81
                                                  pe_scenarios),
 
82
                         suite)
 
83
 
 
84
    dir_reader_tests, remaining_tests = tests.split_suite_by_condition(
 
85
        remaining_tests, tests.condition_isinstance(
 
86
            test_dirstate.TestCaseWithDirState))
 
87
    tests.multiply_tests(dir_reader_tests, dir_reader_scenarios, suite)
 
88
    suite.addTest(remaining_tests)
 
89
 
 
90
    return suite
 
91
 
 
92
 
 
93
class TestBisectPathMixin(object):
 
94
    """Test that _bisect_path_*() returns the expected values.
 
95
 
 
96
    _bisect_path_* is intended to work like bisect.bisect_*() except it
 
97
    knows it is working on paths that are sorted by ('path', 'to', 'foo')
 
98
    chunks rather than by raw 'path/to/foo'.
 
99
 
 
100
    Test Cases should inherit from this and override ``get_bisect_path`` return
 
101
    their implementation, and ``get_bisect`` to return the matching
 
102
    bisect.bisect_* function.
 
103
    """
 
104
 
 
105
    def get_bisect_path(self):
 
106
        """Return an implementation of _bisect_path_*"""
 
107
        raise NotImplementedError
 
108
 
 
109
    def get_bisect(self):
 
110
        """Return a version of bisect.bisect_*.
 
111
 
 
112
        Also, for the 'exists' check, return the offset to the real values.
 
113
        For example bisect_left returns the index of an entry, while
 
114
        bisect_right returns the index *after* an entry
 
115
 
 
116
        :return: (bisect_func, offset)
 
117
        """
 
118
        raise NotImplementedError
 
119
 
 
120
    def assertBisect(self, paths, split_paths, path, exists=True):
 
121
        """Assert that bisect_split works like bisect_left on the split paths.
 
122
 
 
123
        :param paths: A list of path names
 
124
        :param split_paths: A list of path names that are already split up by directory
 
125
            ('path/to/foo' => ('path', 'to', 'foo'))
 
126
        :param path: The path we are indexing.
 
127
        :param exists: The path should be present, so make sure the
 
128
            final location actually points to the right value.
 
129
 
 
130
        All other arguments will be passed along.
 
131
        """
 
132
        bisect_path = self.get_bisect_path()
 
133
        self.assertIsInstance(paths, list)
 
134
        bisect_path_idx = bisect_path(paths, path)
 
135
        split_path = self.split_for_dirblocks([path])[0]
 
136
        bisect_func, offset = self.get_bisect()
 
137
        bisect_split_idx = bisect_func(split_paths, split_path)
 
138
        self.assertEqual(bisect_split_idx, bisect_path_idx,
 
139
                         '%s disagreed. %s != %s'
 
140
                         ' for key %r'
 
141
                         % (bisect_path.__name__,
 
142
                            bisect_split_idx, bisect_path_idx, path)
 
143
                         )
 
144
        if exists:
 
145
            self.assertEqual(path, paths[bisect_path_idx+offset])
 
146
 
 
147
    def split_for_dirblocks(self, paths):
 
148
        dir_split_paths = []
 
149
        for path in paths:
 
150
            dirname, basename = os.path.split(path)
 
151
            dir_split_paths.append((dirname.split('/'), basename))
 
152
        dir_split_paths.sort()
 
153
        return dir_split_paths
 
154
 
 
155
    def test_simple(self):
 
156
        """In the simple case it works just like bisect_left"""
 
157
        paths = ['', 'a', 'b', 'c', 'd']
 
158
        split_paths = self.split_for_dirblocks(paths)
 
159
        for path in paths:
 
160
            self.assertBisect(paths, split_paths, path, exists=True)
 
161
        self.assertBisect(paths, split_paths, '_', exists=False)
 
162
        self.assertBisect(paths, split_paths, 'aa', exists=False)
 
163
        self.assertBisect(paths, split_paths, 'bb', exists=False)
 
164
        self.assertBisect(paths, split_paths, 'cc', exists=False)
 
165
        self.assertBisect(paths, split_paths, 'dd', exists=False)
 
166
        self.assertBisect(paths, split_paths, 'a/a', exists=False)
 
167
        self.assertBisect(paths, split_paths, 'b/b', exists=False)
 
168
        self.assertBisect(paths, split_paths, 'c/c', exists=False)
 
169
        self.assertBisect(paths, split_paths, 'd/d', exists=False)
 
170
 
 
171
    def test_involved(self):
 
172
        """This is where bisect_path_* diverges slightly."""
 
173
        # This is the list of paths and their contents
 
174
        # a/
 
175
        #   a/
 
176
        #     a
 
177
        #     z
 
178
        #   a-a/
 
179
        #     a
 
180
        #   a-z/
 
181
        #     z
 
182
        #   a=a/
 
183
        #     a
 
184
        #   a=z/
 
185
        #     z
 
186
        #   z/
 
187
        #     a
 
188
        #     z
 
189
        #   z-a
 
190
        #   z-z
 
191
        #   z=a
 
192
        #   z=z
 
193
        # a-a/
 
194
        #   a
 
195
        # a-z/
 
196
        #   z
 
197
        # a=a/
 
198
        #   a
 
199
        # a=z/
 
200
        #   z
 
201
        # This is the exact order that is stored by dirstate
 
202
        # All children in a directory are mentioned before an children of
 
203
        # children are mentioned.
 
204
        # So all the root-directory paths, then all the
 
205
        # first sub directory, etc.
 
206
        paths = [# content of '/'
 
207
                 '', 'a', 'a-a', 'a-z', 'a=a', 'a=z',
 
208
                 # content of 'a/'
 
209
                 'a/a', 'a/a-a', 'a/a-z',
 
210
                 'a/a=a', 'a/a=z',
 
211
                 'a/z', 'a/z-a', 'a/z-z',
 
212
                 'a/z=a', 'a/z=z',
 
213
                 # content of 'a/a/'
 
214
                 'a/a/a', 'a/a/z',
 
215
                 # content of 'a/a-a'
 
216
                 'a/a-a/a',
 
217
                 # content of 'a/a-z'
 
218
                 'a/a-z/z',
 
219
                 # content of 'a/a=a'
 
220
                 'a/a=a/a',
 
221
                 # content of 'a/a=z'
 
222
                 'a/a=z/z',
 
223
                 # content of 'a/z/'
 
224
                 'a/z/a', 'a/z/z',
 
225
                 # content of 'a-a'
 
226
                 'a-a/a',
 
227
                 # content of 'a-z'
 
228
                 'a-z/z',
 
229
                 # content of 'a=a'
 
230
                 'a=a/a',
 
231
                 # content of 'a=z'
 
232
                 'a=z/z',
 
233
                ]
 
234
        split_paths = self.split_for_dirblocks(paths)
 
235
        sorted_paths = []
 
236
        for dir_parts, basename in split_paths:
 
237
            if dir_parts == ['']:
 
238
                sorted_paths.append(basename)
 
239
            else:
 
240
                sorted_paths.append('/'.join(dir_parts + [basename]))
 
241
 
 
242
        self.assertEqual(sorted_paths, paths)
 
243
 
 
244
        for path in paths:
 
245
            self.assertBisect(paths, split_paths, path, exists=True)
 
246
 
 
247
 
 
248
class TestBisectPathLeft(tests.TestCase, TestBisectPathMixin):
 
249
    """Run all Bisect Path tests against _bisect_path_left."""
 
250
 
 
251
    def get_bisect_path(self):
 
252
        from bzrlib._dirstate_helpers_py import _bisect_path_left
 
253
        return _bisect_path_left
 
254
 
 
255
    def get_bisect(self):
 
256
        return bisect.bisect_left, 0
 
257
 
 
258
 
 
259
class TestCompiledBisectPathLeft(TestBisectPathLeft):
 
260
    """Run all Bisect Path tests against _bisect_path_lect"""
 
261
 
 
262
    _test_needs_features = [CompiledDirstateHelpersFeature]
 
263
 
 
264
    def get_bisect_path(self):
 
265
        from bzrlib._dirstate_helpers_pyx import _bisect_path_left
 
266
        return _bisect_path_left
 
267
 
 
268
 
 
269
class TestBisectPathRight(tests.TestCase, TestBisectPathMixin):
 
270
    """Run all Bisect Path tests against _bisect_path_right"""
 
271
 
 
272
    def get_bisect_path(self):
 
273
        from bzrlib._dirstate_helpers_py import _bisect_path_right
 
274
        return _bisect_path_right
 
275
 
 
276
    def get_bisect(self):
 
277
        return bisect.bisect_right, -1
 
278
 
 
279
 
 
280
class TestCompiledBisectPathRight(TestBisectPathRight):
 
281
    """Run all Bisect Path tests against _bisect_path_right"""
 
282
 
 
283
    _test_needs_features = [CompiledDirstateHelpersFeature]
 
284
 
 
285
    def get_bisect_path(self):
 
286
        from bzrlib._dirstate_helpers_pyx import _bisect_path_right
 
287
        return _bisect_path_right
 
288
 
 
289
 
 
290
class TestBisectDirblock(tests.TestCase):
 
291
    """Test that bisect_dirblock() returns the expected values.
 
292
 
 
293
    bisect_dirblock is intended to work like bisect.bisect_left() except it
 
294
    knows it is working on dirblocks and that dirblocks are sorted by ('path',
 
295
    'to', 'foo') chunks rather than by raw 'path/to/foo'.
 
296
 
 
297
    This test is parameterized by calling get_bisect_dirblock(). Child test
 
298
    cases can override this function to test against a different
 
299
    implementation.
 
300
    """
 
301
 
 
302
    def get_bisect_dirblock(self):
 
303
        """Return an implementation of bisect_dirblock"""
 
304
        from bzrlib._dirstate_helpers_py import bisect_dirblock
 
305
        return bisect_dirblock
 
306
 
 
307
    def assertBisect(self, dirblocks, split_dirblocks, path, *args, **kwargs):
 
308
        """Assert that bisect_split works like bisect_left on the split paths.
 
309
 
 
310
        :param dirblocks: A list of (path, [info]) pairs.
 
311
        :param split_dirblocks: A list of ((split, path), [info]) pairs.
 
312
        :param path: The path we are indexing.
 
313
 
 
314
        All other arguments will be passed along.
 
315
        """
 
316
        bisect_dirblock = self.get_bisect_dirblock()
 
317
        self.assertIsInstance(dirblocks, list)
 
318
        bisect_split_idx = bisect_dirblock(dirblocks, path, *args, **kwargs)
 
319
        split_dirblock = (path.split('/'), [])
 
320
        bisect_left_idx = bisect.bisect_left(split_dirblocks, split_dirblock,
 
321
                                             *args)
 
322
        self.assertEqual(bisect_left_idx, bisect_split_idx,
 
323
                         'bisect_split disagreed. %s != %s'
 
324
                         ' for key %r'
 
325
                         % (bisect_left_idx, bisect_split_idx, path)
 
326
                         )
 
327
 
 
328
    def paths_to_dirblocks(self, paths):
 
329
        """Convert a list of paths into dirblock form.
 
330
 
 
331
        Also, ensure that the paths are in proper sorted order.
 
332
        """
 
333
        dirblocks = [(path, []) for path in paths]
 
334
        split_dirblocks = [(path.split('/'), []) for path in paths]
 
335
        self.assertEqual(sorted(split_dirblocks), split_dirblocks)
 
336
        return dirblocks, split_dirblocks
 
337
 
 
338
    def test_simple(self):
 
339
        """In the simple case it works just like bisect_left"""
 
340
        paths = ['', 'a', 'b', 'c', 'd']
 
341
        dirblocks, split_dirblocks = self.paths_to_dirblocks(paths)
 
342
        for path in paths:
 
343
            self.assertBisect(dirblocks, split_dirblocks, path)
 
344
        self.assertBisect(dirblocks, split_dirblocks, '_')
 
345
        self.assertBisect(dirblocks, split_dirblocks, 'aa')
 
346
        self.assertBisect(dirblocks, split_dirblocks, 'bb')
 
347
        self.assertBisect(dirblocks, split_dirblocks, 'cc')
 
348
        self.assertBisect(dirblocks, split_dirblocks, 'dd')
 
349
        self.assertBisect(dirblocks, split_dirblocks, 'a/a')
 
350
        self.assertBisect(dirblocks, split_dirblocks, 'b/b')
 
351
        self.assertBisect(dirblocks, split_dirblocks, 'c/c')
 
352
        self.assertBisect(dirblocks, split_dirblocks, 'd/d')
 
353
 
 
354
    def test_involved(self):
 
355
        """This is where bisect_left diverges slightly."""
 
356
        paths = ['', 'a',
 
357
                 'a/a', 'a/a/a', 'a/a/z', 'a/a-a', 'a/a-z',
 
358
                 'a/z', 'a/z/a', 'a/z/z', 'a/z-a', 'a/z-z',
 
359
                 'a-a', 'a-z',
 
360
                 'z', 'z/a/a', 'z/a/z', 'z/a-a', 'z/a-z',
 
361
                 'z/z', 'z/z/a', 'z/z/z', 'z/z-a', 'z/z-z',
 
362
                 'z-a', 'z-z',
 
363
                ]
 
364
        dirblocks, split_dirblocks = self.paths_to_dirblocks(paths)
 
365
        for path in paths:
 
366
            self.assertBisect(dirblocks, split_dirblocks, path)
 
367
 
 
368
    def test_involved_cached(self):
 
369
        """This is where bisect_left diverges slightly."""
 
370
        paths = ['', 'a',
 
371
                 'a/a', 'a/a/a', 'a/a/z', 'a/a-a', 'a/a-z',
 
372
                 'a/z', 'a/z/a', 'a/z/z', 'a/z-a', 'a/z-z',
 
373
                 'a-a', 'a-z',
 
374
                 'z', 'z/a/a', 'z/a/z', 'z/a-a', 'z/a-z',
 
375
                 'z/z', 'z/z/a', 'z/z/z', 'z/z-a', 'z/z-z',
 
376
                 'z-a', 'z-z',
 
377
                ]
 
378
        cache = {}
 
379
        dirblocks, split_dirblocks = self.paths_to_dirblocks(paths)
 
380
        for path in paths:
 
381
            self.assertBisect(dirblocks, split_dirblocks, path, cache=cache)
 
382
 
 
383
 
 
384
class TestCompiledBisectDirblock(TestBisectDirblock):
 
385
    """Test that bisect_dirblock() returns the expected values.
 
386
 
 
387
    bisect_dirblock is intended to work like bisect.bisect_left() except it
 
388
    knows it is working on dirblocks and that dirblocks are sorted by ('path',
 
389
    'to', 'foo') chunks rather than by raw 'path/to/foo'.
 
390
 
 
391
    This runs all the normal tests that TestBisectDirblock did, but uses the
 
392
    compiled version.
 
393
    """
 
394
 
 
395
    _test_needs_features = [CompiledDirstateHelpersFeature]
 
396
 
 
397
    def get_bisect_dirblock(self):
 
398
        from bzrlib._dirstate_helpers_pyx import bisect_dirblock
 
399
        return bisect_dirblock
 
400
 
 
401
 
 
402
class TestCmpByDirs(tests.TestCase):
 
403
    """Test an implementation of cmp_by_dirs()
 
404
 
 
405
    cmp_by_dirs() compares 2 paths by their directory sections, rather than as
 
406
    plain strings.
 
407
 
 
408
    Child test cases can override ``get_cmp_by_dirs`` to test a specific
 
409
    implementation.
 
410
    """
 
411
 
 
412
    def get_cmp_by_dirs(self):
 
413
        """Get a specific implementation of cmp_by_dirs."""
 
414
        from bzrlib._dirstate_helpers_py import cmp_by_dirs
 
415
        return cmp_by_dirs
 
416
 
 
417
    def assertCmpByDirs(self, expected, str1, str2):
 
418
        """Compare the two strings, in both directions.
 
419
 
 
420
        :param expected: The expected comparison value. -1 means str1 comes
 
421
            first, 0 means they are equal, 1 means str2 comes first
 
422
        :param str1: string to compare
 
423
        :param str2: string to compare
 
424
        """
 
425
        cmp_by_dirs = self.get_cmp_by_dirs()
 
426
        if expected == 0:
 
427
            self.assertEqual(str1, str2)
 
428
            self.assertEqual(0, cmp_by_dirs(str1, str2))
 
429
            self.assertEqual(0, cmp_by_dirs(str2, str1))
 
430
        elif expected > 0:
 
431
            self.assertPositive(cmp_by_dirs(str1, str2))
 
432
            self.assertNegative(cmp_by_dirs(str2, str1))
 
433
        else:
 
434
            self.assertNegative(cmp_by_dirs(str1, str2))
 
435
            self.assertPositive(cmp_by_dirs(str2, str1))
 
436
 
 
437
    def test_cmp_empty(self):
 
438
        """Compare against the empty string."""
 
439
        self.assertCmpByDirs(0, '', '')
 
440
        self.assertCmpByDirs(1, 'a', '')
 
441
        self.assertCmpByDirs(1, 'ab', '')
 
442
        self.assertCmpByDirs(1, 'abc', '')
 
443
        self.assertCmpByDirs(1, 'abcd', '')
 
444
        self.assertCmpByDirs(1, 'abcde', '')
 
445
        self.assertCmpByDirs(1, 'abcdef', '')
 
446
        self.assertCmpByDirs(1, 'abcdefg', '')
 
447
        self.assertCmpByDirs(1, 'abcdefgh', '')
 
448
        self.assertCmpByDirs(1, 'abcdefghi', '')
 
449
        self.assertCmpByDirs(1, 'test/ing/a/path/', '')
 
450
 
 
451
    def test_cmp_same_str(self):
 
452
        """Compare the same string"""
 
453
        self.assertCmpByDirs(0, 'a', 'a')
 
454
        self.assertCmpByDirs(0, 'ab', 'ab')
 
455
        self.assertCmpByDirs(0, 'abc', 'abc')
 
456
        self.assertCmpByDirs(0, 'abcd', 'abcd')
 
457
        self.assertCmpByDirs(0, 'abcde', 'abcde')
 
458
        self.assertCmpByDirs(0, 'abcdef', 'abcdef')
 
459
        self.assertCmpByDirs(0, 'abcdefg', 'abcdefg')
 
460
        self.assertCmpByDirs(0, 'abcdefgh', 'abcdefgh')
 
461
        self.assertCmpByDirs(0, 'abcdefghi', 'abcdefghi')
 
462
        self.assertCmpByDirs(0, 'testing a long string', 'testing a long string')
 
463
        self.assertCmpByDirs(0, 'x'*10000, 'x'*10000)
 
464
        self.assertCmpByDirs(0, 'a/b', 'a/b')
 
465
        self.assertCmpByDirs(0, 'a/b/c', 'a/b/c')
 
466
        self.assertCmpByDirs(0, 'a/b/c/d', 'a/b/c/d')
 
467
        self.assertCmpByDirs(0, 'a/b/c/d/e', 'a/b/c/d/e')
 
468
 
 
469
    def test_simple_paths(self):
 
470
        """Compare strings that act like normal string comparison"""
 
471
        self.assertCmpByDirs(-1, 'a', 'b')
 
472
        self.assertCmpByDirs(-1, 'aa', 'ab')
 
473
        self.assertCmpByDirs(-1, 'ab', 'bb')
 
474
        self.assertCmpByDirs(-1, 'aaa', 'aab')
 
475
        self.assertCmpByDirs(-1, 'aab', 'abb')
 
476
        self.assertCmpByDirs(-1, 'abb', 'bbb')
 
477
        self.assertCmpByDirs(-1, 'aaaa', 'aaab')
 
478
        self.assertCmpByDirs(-1, 'aaab', 'aabb')
 
479
        self.assertCmpByDirs(-1, 'aabb', 'abbb')
 
480
        self.assertCmpByDirs(-1, 'abbb', 'bbbb')
 
481
        self.assertCmpByDirs(-1, 'aaaaa', 'aaaab')
 
482
        self.assertCmpByDirs(-1, 'a/a', 'a/b')
 
483
        self.assertCmpByDirs(-1, 'a/b', 'b/b')
 
484
        self.assertCmpByDirs(-1, 'a/a/a', 'a/a/b')
 
485
        self.assertCmpByDirs(-1, 'a/a/b', 'a/b/b')
 
486
        self.assertCmpByDirs(-1, 'a/b/b', 'b/b/b')
 
487
        self.assertCmpByDirs(-1, 'a/a/a/a', 'a/a/a/b')
 
488
        self.assertCmpByDirs(-1, 'a/a/a/b', 'a/a/b/b')
 
489
        self.assertCmpByDirs(-1, 'a/a/b/b', 'a/b/b/b')
 
490
        self.assertCmpByDirs(-1, 'a/b/b/b', 'b/b/b/b')
 
491
        self.assertCmpByDirs(-1, 'a/a/a/a/a', 'a/a/a/a/b')
 
492
 
 
493
    def test_tricky_paths(self):
 
494
        self.assertCmpByDirs(1, 'ab/cd/ef', 'ab/cc/ef')
 
495
        self.assertCmpByDirs(1, 'ab/cd/ef', 'ab/c/ef')
 
496
        self.assertCmpByDirs(-1, 'ab/cd/ef', 'ab/cd-ef')
 
497
        self.assertCmpByDirs(-1, 'ab/cd', 'ab/cd-')
 
498
        self.assertCmpByDirs(-1, 'ab/cd', 'ab-cd')
 
499
 
 
500
    def test_cmp_unicode_not_allowed(self):
 
501
        cmp_by_dirs = self.get_cmp_by_dirs()
 
502
        self.assertRaises(TypeError, cmp_by_dirs, u'Unicode', 'str')
 
503
        self.assertRaises(TypeError, cmp_by_dirs, 'str', u'Unicode')
 
504
        self.assertRaises(TypeError, cmp_by_dirs, u'Unicode', u'Unicode')
 
505
 
 
506
    def test_cmp_non_ascii(self):
 
507
        self.assertCmpByDirs(-1, '\xc2\xb5', '\xc3\xa5') # u'\xb5', u'\xe5'
 
508
        self.assertCmpByDirs(-1, 'a', '\xc3\xa5') # u'a', u'\xe5'
 
509
        self.assertCmpByDirs(-1, 'b', '\xc2\xb5') # u'b', u'\xb5'
 
510
        self.assertCmpByDirs(-1, 'a/b', 'a/\xc3\xa5') # u'a/b', u'a/\xe5'
 
511
        self.assertCmpByDirs(-1, 'b/a', 'b/\xc2\xb5') # u'b/a', u'b/\xb5'
 
512
 
 
513
 
 
514
class TestCompiledCmpByDirs(TestCmpByDirs):
 
515
    """Test the pyrex implementation of cmp_by_dirs"""
 
516
 
 
517
    _test_needs_features = [CompiledDirstateHelpersFeature]
 
518
 
 
519
    def get_cmp_by_dirs(self):
 
520
        from bzrlib._dirstate_helpers_pyx import cmp_by_dirs
 
521
        return cmp_by_dirs
 
522
 
 
523
 
 
524
class TestCmpPathByDirblock(tests.TestCase):
 
525
    """Test an implementation of _cmp_path_by_dirblock()
 
526
 
 
527
    _cmp_path_by_dirblock() compares two paths using the sort order used by
 
528
    DirState. All paths in the same directory are sorted together.
 
529
 
 
530
    Child test cases can override ``get_cmp_path_by_dirblock`` to test a specific
 
531
    implementation.
 
532
    """
 
533
 
 
534
    def get_cmp_path_by_dirblock(self):
 
535
        """Get a specific implementation of _cmp_path_by_dirblock."""
 
536
        from bzrlib._dirstate_helpers_py import _cmp_path_by_dirblock
 
537
        return _cmp_path_by_dirblock
 
538
 
 
539
    def assertCmpPathByDirblock(self, paths):
 
540
        """Compare all paths and make sure they evaluate to the correct order.
 
541
 
 
542
        This does N^2 comparisons. It is assumed that ``paths`` is properly
 
543
        sorted list.
 
544
 
 
545
        :param paths: a sorted list of paths to compare
 
546
        """
 
547
        # First, make sure the paths being passed in are correct
 
548
        def _key(p):
 
549
            dirname, basename = os.path.split(p)
 
550
            return dirname.split('/'), basename
 
551
        self.assertEqual(sorted(paths, key=_key), paths)
 
552
 
 
553
        cmp_path_by_dirblock = self.get_cmp_path_by_dirblock()
 
554
        for idx1, path1 in enumerate(paths):
 
555
            for idx2, path2 in enumerate(paths):
 
556
                cmp_val = cmp_path_by_dirblock(path1, path2)
 
557
                if idx1 < idx2:
 
558
                    self.assertTrue(cmp_val < 0,
 
559
                        '%s did not state that %r came before %r, cmp=%s'
 
560
                        % (cmp_path_by_dirblock.__name__,
 
561
                           path1, path2, cmp_val))
 
562
                elif idx1 > idx2:
 
563
                    self.assertTrue(cmp_val > 0,
 
564
                        '%s did not state that %r came after %r, cmp=%s'
 
565
                        % (cmp_path_by_dirblock.__name__,
 
566
                           path1, path2, cmp_val))
 
567
                else: # idx1 == idx2
 
568
                    self.assertTrue(cmp_val == 0,
 
569
                        '%s did not state that %r == %r, cmp=%s'
 
570
                        % (cmp_path_by_dirblock.__name__,
 
571
                           path1, path2, cmp_val))
 
572
 
 
573
    def test_cmp_simple_paths(self):
 
574
        """Compare against the empty string."""
 
575
        self.assertCmpPathByDirblock(['', 'a', 'ab', 'abc', 'a/b/c', 'b/d/e'])
 
576
        self.assertCmpPathByDirblock(['kl', 'ab/cd', 'ab/ef', 'gh/ij'])
 
577
 
 
578
    def test_tricky_paths(self):
 
579
        self.assertCmpPathByDirblock([
 
580
            # Contents of ''
 
581
            '', 'a', 'a-a', 'a=a', 'b',
 
582
            # Contents of 'a'
 
583
            'a/a', 'a/a-a', 'a/a=a', 'a/b',
 
584
            # Contents of 'a/a'
 
585
            'a/a/a', 'a/a/a-a', 'a/a/a=a',
 
586
            # Contents of 'a/a/a'
 
587
            'a/a/a/a', 'a/a/a/b',
 
588
            # Contents of 'a/a/a-a',
 
589
            'a/a/a-a/a', 'a/a/a-a/b',
 
590
            # Contents of 'a/a/a=a',
 
591
            'a/a/a=a/a', 'a/a/a=a/b',
 
592
            # Contents of 'a/a-a'
 
593
            'a/a-a/a',
 
594
            # Contents of 'a/a-a/a'
 
595
            'a/a-a/a/a', 'a/a-a/a/b',
 
596
            # Contents of 'a/a=a'
 
597
            'a/a=a/a',
 
598
            # Contents of 'a/b'
 
599
            'a/b/a', 'a/b/b',
 
600
            # Contents of 'a-a',
 
601
            'a-a/a', 'a-a/b',
 
602
            # Contents of 'a=a',
 
603
            'a=a/a', 'a=a/b',
 
604
            # Contents of 'b',
 
605
            'b/a', 'b/b',
 
606
            ])
 
607
        self.assertCmpPathByDirblock([
 
608
                 # content of '/'
 
609
                 '', 'a', 'a-a', 'a-z', 'a=a', 'a=z',
 
610
                 # content of 'a/'
 
611
                 'a/a', 'a/a-a', 'a/a-z',
 
612
                 'a/a=a', 'a/a=z',
 
613
                 'a/z', 'a/z-a', 'a/z-z',
 
614
                 'a/z=a', 'a/z=z',
 
615
                 # content of 'a/a/'
 
616
                 'a/a/a', 'a/a/z',
 
617
                 # content of 'a/a-a'
 
618
                 'a/a-a/a',
 
619
                 # content of 'a/a-z'
 
620
                 'a/a-z/z',
 
621
                 # content of 'a/a=a'
 
622
                 'a/a=a/a',
 
623
                 # content of 'a/a=z'
 
624
                 'a/a=z/z',
 
625
                 # content of 'a/z/'
 
626
                 'a/z/a', 'a/z/z',
 
627
                 # content of 'a-a'
 
628
                 'a-a/a',
 
629
                 # content of 'a-z'
 
630
                 'a-z/z',
 
631
                 # content of 'a=a'
 
632
                 'a=a/a',
 
633
                 # content of 'a=z'
 
634
                 'a=z/z',
 
635
                ])
 
636
 
 
637
    def test_unicode_not_allowed(self):
 
638
        cmp_path_by_dirblock = self.get_cmp_path_by_dirblock()
 
639
        self.assertRaises(TypeError, cmp_path_by_dirblock, u'Uni', 'str')
 
640
        self.assertRaises(TypeError, cmp_path_by_dirblock, 'str', u'Uni')
 
641
        self.assertRaises(TypeError, cmp_path_by_dirblock, u'Uni', u'Uni')
 
642
        self.assertRaises(TypeError, cmp_path_by_dirblock, u'x/Uni', 'x/str')
 
643
        self.assertRaises(TypeError, cmp_path_by_dirblock, 'x/str', u'x/Uni')
 
644
        self.assertRaises(TypeError, cmp_path_by_dirblock, u'x/Uni', u'x/Uni')
 
645
 
 
646
    def test_nonascii(self):
 
647
        self.assertCmpPathByDirblock([
 
648
            # content of '/'
 
649
            '', 'a', '\xc2\xb5', '\xc3\xa5',
 
650
            # content of 'a'
 
651
            'a/a', 'a/\xc2\xb5', 'a/\xc3\xa5',
 
652
            # content of 'a/a'
 
653
            'a/a/a', 'a/a/\xc2\xb5', 'a/a/\xc3\xa5',
 
654
            # content of 'a/\xc2\xb5'
 
655
            'a/\xc2\xb5/a', 'a/\xc2\xb5/\xc2\xb5', 'a/\xc2\xb5/\xc3\xa5',
 
656
            # content of 'a/\xc3\xa5'
 
657
            'a/\xc3\xa5/a', 'a/\xc3\xa5/\xc2\xb5', 'a/\xc3\xa5/\xc3\xa5',
 
658
            # content of '\xc2\xb5'
 
659
            '\xc2\xb5/a', '\xc2\xb5/\xc2\xb5', '\xc2\xb5/\xc3\xa5',
 
660
            # content of '\xc2\xe5'
 
661
            '\xc3\xa5/a', '\xc3\xa5/\xc2\xb5', '\xc3\xa5/\xc3\xa5',
 
662
            ])
 
663
 
 
664
 
 
665
class TestCompiledCmpPathByDirblock(TestCmpPathByDirblock):
 
666
    """Test the pyrex implementation of _cmp_path_by_dirblock"""
 
667
 
 
668
    _test_needs_features = [CompiledDirstateHelpersFeature]
 
669
 
 
670
    def get_cmp_by_dirs(self):
 
671
        from bzrlib._dirstate_helpers_pyx import _cmp_path_by_dirblock
 
672
        return _cmp_path_by_dirblock
 
673
 
 
674
 
 
675
class TestMemRChr(tests.TestCase):
 
676
    """Test memrchr functionality"""
 
677
 
 
678
    _test_needs_features = [CompiledDirstateHelpersFeature]
 
679
 
 
680
    def assertMemRChr(self, expected, s, c):
 
681
        from bzrlib._dirstate_helpers_pyx import _py_memrchr
 
682
        self.assertEqual(expected, _py_memrchr(s, c))
 
683
 
 
684
    def test_missing(self):
 
685
        self.assertMemRChr(None, '', 'a')
 
686
        self.assertMemRChr(None, '', 'c')
 
687
        self.assertMemRChr(None, 'abcdefghijklm', 'q')
 
688
        self.assertMemRChr(None, 'aaaaaaaaaaaaaaaaaaaaaaa', 'b')
 
689
 
 
690
    def test_single_entry(self):
 
691
        self.assertMemRChr(0, 'abcdefghijklm', 'a')
 
692
        self.assertMemRChr(1, 'abcdefghijklm', 'b')
 
693
        self.assertMemRChr(2, 'abcdefghijklm', 'c')
 
694
        self.assertMemRChr(10, 'abcdefghijklm', 'k')
 
695
        self.assertMemRChr(11, 'abcdefghijklm', 'l')
 
696
        self.assertMemRChr(12, 'abcdefghijklm', 'm')
 
697
 
 
698
    def test_multiple(self):
 
699
        self.assertMemRChr(10, 'abcdefjklmabcdefghijklm', 'a')
 
700
        self.assertMemRChr(11, 'abcdefjklmabcdefghijklm', 'b')
 
701
        self.assertMemRChr(12, 'abcdefjklmabcdefghijklm', 'c')
 
702
        self.assertMemRChr(20, 'abcdefjklmabcdefghijklm', 'k')
 
703
        self.assertMemRChr(21, 'abcdefjklmabcdefghijklm', 'l')
 
704
        self.assertMemRChr(22, 'abcdefjklmabcdefghijklm', 'm')
 
705
        self.assertMemRChr(22, 'aaaaaaaaaaaaaaaaaaaaaaa', 'a')
 
706
 
 
707
    def test_with_nulls(self):
 
708
        self.assertMemRChr(10, 'abc\0\0\0jklmabc\0\0\0ghijklm', 'a')
 
709
        self.assertMemRChr(11, 'abc\0\0\0jklmabc\0\0\0ghijklm', 'b')
 
710
        self.assertMemRChr(12, 'abc\0\0\0jklmabc\0\0\0ghijklm', 'c')
 
711
        self.assertMemRChr(20, 'abc\0\0\0jklmabc\0\0\0ghijklm', 'k')
 
712
        self.assertMemRChr(21, 'abc\0\0\0jklmabc\0\0\0ghijklm', 'l')
 
713
        self.assertMemRChr(22, 'abc\0\0\0jklmabc\0\0\0ghijklm', 'm')
 
714
        self.assertMemRChr(22, 'aaa\0\0\0aaaaaaa\0\0\0aaaaaaa', 'a')
 
715
        self.assertMemRChr(9, '\0\0\0\0\0\0\0\0\0\0', '\0')
 
716
 
 
717
 
 
718
class TestReadDirblocks(test_dirstate.TestCaseWithDirState):
 
719
    """Test an implementation of _read_dirblocks()
 
720
 
 
721
    _read_dirblocks() reads in all of the dirblock information from the disk
 
722
    file.
 
723
 
 
724
    Child test cases can override ``get_read_dirblocks`` to test a specific
 
725
    implementation.
 
726
    """
 
727
 
 
728
    def get_read_dirblocks(self):
 
729
        from bzrlib._dirstate_helpers_py import _read_dirblocks
 
730
        return _read_dirblocks
 
731
 
 
732
    def test_smoketest(self):
 
733
        """Make sure that we can create and read back a simple file."""
 
734
        tree, state, expected = self.create_basic_dirstate()
 
735
        del tree
 
736
        state._read_header_if_needed()
 
737
        self.assertEqual(dirstate.DirState.NOT_IN_MEMORY,
 
738
                         state._dirblock_state)
 
739
        read_dirblocks = self.get_read_dirblocks()
 
740
        read_dirblocks(state)
 
741
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
742
                         state._dirblock_state)
 
743
 
 
744
    def test_trailing_garbage(self):
 
745
        tree, state, expected = self.create_basic_dirstate()
 
746
        # We can modify the file as long as it hasn't been read yet.
 
747
        f = open('dirstate', 'ab')
 
748
        try:
 
749
            # Add bogus trailing garbage
 
750
            f.write('bogus\n')
 
751
        finally:
 
752
            f.close()
 
753
        e = self.assertRaises(errors.DirstateCorrupt,
 
754
                              state._read_dirblocks_if_needed)
 
755
        # Make sure we mention the bogus characters in the error
 
756
        self.assertContainsRe(str(e), 'bogus')
 
757
 
 
758
 
 
759
class TestCompiledReadDirblocks(TestReadDirblocks):
 
760
    """Test the pyrex implementation of _read_dirblocks"""
 
761
 
 
762
    _test_needs_features = [CompiledDirstateHelpersFeature]
 
763
 
 
764
    def get_read_dirblocks(self):
 
765
        from bzrlib._dirstate_helpers_pyx import _read_dirblocks
 
766
        return _read_dirblocks
 
767
 
 
768
 
 
769
class TestUsingCompiledIfAvailable(tests.TestCase):
 
770
    """Check that any compiled functions that are available are the default.
 
771
 
 
772
    It is possible to have typos, etc in the import line, such that
 
773
    _dirstate_helpers_pyx is actually available, but the compiled functions are
 
774
    not being used.
 
775
    """
 
776
 
 
777
    def test_bisect_dirblock(self):
 
778
        if CompiledDirstateHelpersFeature.available():
 
779
            from bzrlib._dirstate_helpers_pyx import bisect_dirblock
 
780
        else:
 
781
            from bzrlib._dirstate_helpers_py import bisect_dirblock
 
782
        self.assertIs(bisect_dirblock, dirstate.bisect_dirblock)
 
783
 
 
784
    def test__bisect_path_left(self):
 
785
        if CompiledDirstateHelpersFeature.available():
 
786
            from bzrlib._dirstate_helpers_pyx import _bisect_path_left
 
787
        else:
 
788
            from bzrlib._dirstate_helpers_py import _bisect_path_left
 
789
        self.assertIs(_bisect_path_left, dirstate._bisect_path_left)
 
790
 
 
791
    def test__bisect_path_right(self):
 
792
        if CompiledDirstateHelpersFeature.available():
 
793
            from bzrlib._dirstate_helpers_pyx import _bisect_path_right
 
794
        else:
 
795
            from bzrlib._dirstate_helpers_py import _bisect_path_right
 
796
        self.assertIs(_bisect_path_right, dirstate._bisect_path_right)
 
797
 
 
798
    def test_cmp_by_dirs(self):
 
799
        if CompiledDirstateHelpersFeature.available():
 
800
            from bzrlib._dirstate_helpers_pyx import cmp_by_dirs
 
801
        else:
 
802
            from bzrlib._dirstate_helpers_py import cmp_by_dirs
 
803
        self.assertIs(cmp_by_dirs, dirstate.cmp_by_dirs)
 
804
 
 
805
    def test__read_dirblocks(self):
 
806
        if CompiledDirstateHelpersFeature.available():
 
807
            from bzrlib._dirstate_helpers_pyx import _read_dirblocks
 
808
        else:
 
809
            from bzrlib._dirstate_helpers_py import _read_dirblocks
 
810
        self.assertIs(_read_dirblocks, dirstate._read_dirblocks)
 
811
 
 
812
    def test_update_entry(self):
 
813
        if CompiledDirstateHelpersFeature.available():
 
814
            from bzrlib._dirstate_helpers_pyx import update_entry
 
815
        else:
 
816
            from bzrlib.dirstate import update_entry
 
817
        self.assertIs(update_entry, dirstate.update_entry)
 
818
 
 
819
    def test_process_entry(self):
 
820
        if CompiledDirstateHelpersFeature.available():
 
821
            from bzrlib._dirstate_helpers_pyx import ProcessEntryC
 
822
            self.assertIs(ProcessEntryC, dirstate._process_entry)
 
823
        else:
 
824
            from bzrlib.dirstate import ProcessEntryPython
 
825
            self.assertIs(ProcessEntryPython, dirstate._process_entry)
 
826
 
 
827
 
 
828
class TestUpdateEntry(test_dirstate.TestCaseWithDirState):
 
829
    """Test the DirState.update_entry functions"""
 
830
 
 
831
    # Set by load_tests
 
832
    update_entry = None
 
833
 
 
834
    def setUp(self):
 
835
        super(TestUpdateEntry, self).setUp()
 
836
        orig = dirstate.update_entry
 
837
        def cleanup():
 
838
            dirstate.update_entry = orig
 
839
        self.addCleanup(cleanup)
 
840
        dirstate.update_entry = self.update_entry
 
841
 
 
842
    def get_state_with_a(self):
 
843
        """Create a DirState tracking a single object named 'a'"""
 
844
        state = test_dirstate.InstrumentedDirState.initialize('dirstate')
 
845
        self.addCleanup(state.unlock)
 
846
        state.add('a', 'a-id', 'file', None, '')
 
847
        entry = state._get_entry(0, path_utf8='a')
 
848
        return state, entry
 
849
 
 
850
    def test_observed_sha1_cachable(self):
 
851
        state, entry = self.get_state_with_a()
 
852
        atime = time.time() - 10
 
853
        self.build_tree(['a'])
 
854
        statvalue = os.lstat('a')
 
855
        statvalue = test_dirstate._FakeStat(statvalue.st_size, atime, atime,
 
856
            statvalue.st_dev, statvalue.st_ino, statvalue.st_mode)
 
857
        state._observed_sha1(entry, "foo", statvalue)
 
858
        self.assertEqual('foo', entry[1][0][1])
 
859
        packed_stat = dirstate.pack_stat(statvalue)
 
860
        self.assertEqual(packed_stat, entry[1][0][4])
 
861
 
 
862
    def test_observed_sha1_not_cachable(self):
 
863
        state, entry = self.get_state_with_a()
 
864
        oldval = entry[1][0][1]
 
865
        oldstat = entry[1][0][4]
 
866
        self.build_tree(['a'])
 
867
        statvalue = os.lstat('a')
 
868
        state._observed_sha1(entry, "foo", statvalue)
 
869
        self.assertEqual(oldval, entry[1][0][1])
 
870
        self.assertEqual(oldstat, entry[1][0][4])
 
871
 
 
872
    def test_update_entry(self):
 
873
        state, _ = self.get_state_with_a()
 
874
        tree = self.make_branch_and_tree('tree')
 
875
        tree.lock_write()
 
876
        empty_revid = tree.commit('empty')
 
877
        self.build_tree(['tree/a'])
 
878
        tree.add(['a'], ['a-id'])
 
879
        with_a_id = tree.commit('with_a')
 
880
        self.addCleanup(tree.unlock)
 
881
        state.set_parent_trees(
 
882
            [(empty_revid, tree.branch.repository.revision_tree(empty_revid))],
 
883
            [])
 
884
        entry = state._get_entry(0, path_utf8='a')
 
885
        self.build_tree(['a'])
 
886
        # Add one where we don't provide the stat or sha already
 
887
        self.assertEqual(('', 'a', 'a-id'), entry[0])
 
888
        self.assertEqual(('f', '', 0, False, dirstate.DirState.NULLSTAT),
 
889
                         entry[1][0])
 
890
        # Flush the buffers to disk
 
891
        state.save()
 
892
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
893
                         state._dirblock_state)
 
894
 
 
895
        stat_value = os.lstat('a')
 
896
        packed_stat = dirstate.pack_stat(stat_value)
 
897
        link_or_sha1 = self.update_entry(state, entry, abspath='a',
 
898
                                          stat_value=stat_value)
 
899
        self.assertEqual(None, link_or_sha1)
 
900
 
 
901
        # The dirblock entry should not have cached the file's sha1 (too new)
 
902
        self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
 
903
                         entry[1][0])
 
904
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
905
                         state._dirblock_state)
 
906
        mode = stat_value.st_mode
 
907
        self.assertEqual([('is_exec', mode, False)], state._log)
 
908
 
 
909
        state.save()
 
910
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
911
                         state._dirblock_state)
 
912
 
 
913
        # If we do it again right away, we don't know if the file has changed
 
914
        # so we will re-read the file. Roll the clock back so the file is
 
915
        # guaranteed to look too new.
 
916
        state.adjust_time(-10)
 
917
        del state._log[:]
 
918
 
 
919
        link_or_sha1 = self.update_entry(state, entry, abspath='a',
 
920
                                          stat_value=stat_value)
 
921
        self.assertEqual([('is_exec', mode, False)], state._log)
 
922
        self.assertEqual(None, link_or_sha1)
 
923
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
924
                         state._dirblock_state)
 
925
        self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
 
926
                         entry[1][0])
 
927
        state.save()
 
928
 
 
929
        # If it is cachable (the clock has moved forward) but new it still
 
930
        # won't calculate the sha or cache it.
 
931
        state.adjust_time(+20)
 
932
        del state._log[:]
 
933
        link_or_sha1 = dirstate.update_entry(state, entry, abspath='a',
 
934
                                          stat_value=stat_value)
 
935
        self.assertEqual(None, link_or_sha1)
 
936
        self.assertEqual([('is_exec', mode, False)], state._log)
 
937
        self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
 
938
                         entry[1][0])
 
939
 
 
940
        # If the file is no longer new, and the clock has been moved forward
 
941
        # sufficiently, it will cache the sha.
 
942
        del state._log[:]
 
943
        state.set_parent_trees(
 
944
            [(with_a_id, tree.branch.repository.revision_tree(with_a_id))],
 
945
            [])
 
946
        entry = state._get_entry(0, path_utf8='a')
 
947
 
 
948
        link_or_sha1 = self.update_entry(state, entry, abspath='a',
 
949
                                          stat_value=stat_value)
 
950
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
951
                         link_or_sha1)
 
952
        self.assertEqual([('is_exec', mode, False), ('sha1', 'a')],
 
953
                          state._log)
 
954
        self.assertEqual(('f', link_or_sha1, 14, False, packed_stat),
 
955
                         entry[1][0])
 
956
 
 
957
        # Subsequent calls will just return the cached value
 
958
        del state._log[:]
 
959
        link_or_sha1 = self.update_entry(state, entry, abspath='a',
 
960
                                          stat_value=stat_value)
 
961
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
962
                         link_or_sha1)
 
963
        self.assertEqual([], state._log)
 
964
        self.assertEqual(('f', link_or_sha1, 14, False, packed_stat),
 
965
                         entry[1][0])
 
966
 
 
967
    def test_update_entry_symlink(self):
 
968
        """Update entry should read symlinks."""
 
969
        self.requireFeature(tests.SymlinkFeature)
 
970
        state, entry = self.get_state_with_a()
 
971
        state.save()
 
972
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
973
                         state._dirblock_state)
 
974
        os.symlink('target', 'a')
 
975
 
 
976
        state.adjust_time(-10) # Make the symlink look new
 
977
        stat_value = os.lstat('a')
 
978
        packed_stat = dirstate.pack_stat(stat_value)
 
979
        link_or_sha1 = self.update_entry(state, entry, abspath='a',
 
980
                                          stat_value=stat_value)
 
981
        self.assertEqual('target', link_or_sha1)
 
982
        self.assertEqual([('read_link', 'a', '')], state._log)
 
983
        # Dirblock is not updated (the link is too new)
 
984
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
 
985
                         entry[1])
 
986
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
987
                         state._dirblock_state)
 
988
 
 
989
        # Because the stat_value looks new, we should re-read the target
 
990
        link_or_sha1 = self.update_entry(state, entry, abspath='a',
 
991
                                          stat_value=stat_value)
 
992
        self.assertEqual('target', link_or_sha1)
 
993
        self.assertEqual([('read_link', 'a', ''),
 
994
                          ('read_link', 'a', ''),
 
995
                         ], state._log)
 
996
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
 
997
                         entry[1])
 
998
        state.adjust_time(+20) # Skip into the future, all files look old
 
999
        link_or_sha1 = self.update_entry(state, entry, abspath='a',
 
1000
                                          stat_value=stat_value)
 
1001
        self.assertEqual('target', link_or_sha1)
 
1002
        # We need to re-read the link because only now can we cache it
 
1003
        self.assertEqual([('read_link', 'a', ''),
 
1004
                          ('read_link', 'a', ''),
 
1005
                          ('read_link', 'a', ''),
 
1006
                         ], state._log)
 
1007
        self.assertEqual([('l', 'target', 6, False, packed_stat)],
 
1008
                         entry[1])
 
1009
 
 
1010
        # Another call won't re-read the link
 
1011
        self.assertEqual([('read_link', 'a', ''),
 
1012
                          ('read_link', 'a', ''),
 
1013
                          ('read_link', 'a', ''),
 
1014
                         ], state._log)
 
1015
        link_or_sha1 = self.update_entry(state, entry, abspath='a',
 
1016
                                          stat_value=stat_value)
 
1017
        self.assertEqual('target', link_or_sha1)
 
1018
        self.assertEqual([('l', 'target', 6, False, packed_stat)],
 
1019
                         entry[1])
 
1020
 
 
1021
    def do_update_entry(self, state, entry, abspath):
 
1022
        stat_value = os.lstat(abspath)
 
1023
        return self.update_entry(state, entry, abspath, stat_value)
 
1024
 
 
1025
    def test_update_entry_dir(self):
 
1026
        state, entry = self.get_state_with_a()
 
1027
        self.build_tree(['a/'])
 
1028
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1029
 
 
1030
    def test_update_entry_dir_unchanged(self):
 
1031
        state, entry = self.get_state_with_a()
 
1032
        self.build_tree(['a/'])
 
1033
        state.adjust_time(+20)
 
1034
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1035
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1036
                         state._dirblock_state)
 
1037
        state.save()
 
1038
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1039
                         state._dirblock_state)
 
1040
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1041
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1042
                         state._dirblock_state)
 
1043
 
 
1044
    def test_update_entry_file_unchanged(self):
 
1045
        state, _ = self.get_state_with_a()
 
1046
        tree = self.make_branch_and_tree('tree')
 
1047
        tree.lock_write()
 
1048
        self.build_tree(['tree/a'])
 
1049
        tree.add(['a'], ['a-id'])
 
1050
        with_a_id = tree.commit('witha')
 
1051
        self.addCleanup(tree.unlock)
 
1052
        state.set_parent_trees(
 
1053
            [(with_a_id, tree.branch.repository.revision_tree(with_a_id))],
 
1054
            [])
 
1055
        entry = state._get_entry(0, path_utf8='a')
 
1056
        self.build_tree(['a'])
 
1057
        sha1sum = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
 
1058
        state.adjust_time(+20)
 
1059
        self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
 
1060
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1061
                         state._dirblock_state)
 
1062
        state.save()
 
1063
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1064
                         state._dirblock_state)
 
1065
        self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
 
1066
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1067
                         state._dirblock_state)
 
1068
 
 
1069
    def test_update_entry_tree_reference(self):
 
1070
        state = test_dirstate.InstrumentedDirState.initialize('dirstate')
 
1071
        self.addCleanup(state.unlock)
 
1072
        state.add('r', 'r-id', 'tree-reference', None, '')
 
1073
        self.build_tree(['r/'])
 
1074
        entry = state._get_entry(0, path_utf8='r')
 
1075
        self.do_update_entry(state, entry, 'r')
 
1076
        entry = state._get_entry(0, path_utf8='r')
 
1077
        self.assertEqual('t', entry[1][0][0])
 
1078
 
 
1079
    def create_and_test_file(self, state, entry):
 
1080
        """Create a file at 'a' and verify the state finds it during update.
 
1081
 
 
1082
        The state should already be versioning *something* at 'a'. This makes
 
1083
        sure that state.update_entry recognizes it as a file.
 
1084
        """
 
1085
        self.build_tree(['a'])
 
1086
        stat_value = os.lstat('a')
 
1087
        packed_stat = dirstate.pack_stat(stat_value)
 
1088
 
 
1089
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
 
1090
        self.assertEqual(None, link_or_sha1)
 
1091
        self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
 
1092
                         entry[1])
 
1093
        return packed_stat
 
1094
 
 
1095
    def create_and_test_dir(self, state, entry):
 
1096
        """Create a directory at 'a' and verify the state finds it.
 
1097
 
 
1098
        The state should already be versioning *something* at 'a'. This makes
 
1099
        sure that state.update_entry recognizes it as a directory.
 
1100
        """
 
1101
        self.build_tree(['a/'])
 
1102
        stat_value = os.lstat('a')
 
1103
        packed_stat = dirstate.pack_stat(stat_value)
 
1104
 
 
1105
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
 
1106
        self.assertIs(None, link_or_sha1)
 
1107
        self.assertEqual([('d', '', 0, False, packed_stat)], entry[1])
 
1108
 
 
1109
        return packed_stat
 
1110
 
 
1111
    # FIXME: Add unicode version
 
1112
    def create_and_test_symlink(self, state, entry):
 
1113
        """Create a symlink at 'a' and verify the state finds it.
 
1114
 
 
1115
        The state should already be versioning *something* at 'a'. This makes
 
1116
        sure that state.update_entry recognizes it as a symlink.
 
1117
 
 
1118
        This should not be called if this platform does not have symlink
 
1119
        support.
 
1120
        """
 
1121
        # caller should care about skipping test on platforms without symlinks
 
1122
        os.symlink('path/to/foo', 'a')
 
1123
 
 
1124
        stat_value = os.lstat('a')
 
1125
        packed_stat = dirstate.pack_stat(stat_value)
 
1126
 
 
1127
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
 
1128
        self.assertEqual('path/to/foo', link_or_sha1)
 
1129
        self.assertEqual([('l', 'path/to/foo', 11, False, packed_stat)],
 
1130
                         entry[1])
 
1131
        return packed_stat
 
1132
 
 
1133
    def test_update_file_to_dir(self):
 
1134
        """If a file changes to a directory we return None for the sha.
 
1135
        We also update the inventory record.
 
1136
        """
 
1137
        state, entry = self.get_state_with_a()
 
1138
        # The file sha1 won't be cached unless the file is old
 
1139
        state.adjust_time(+10)
 
1140
        self.create_and_test_file(state, entry)
 
1141
        os.remove('a')
 
1142
        self.create_and_test_dir(state, entry)
 
1143
 
 
1144
    def test_update_file_to_symlink(self):
 
1145
        """File becomes a symlink"""
 
1146
        self.requireFeature(tests.SymlinkFeature)
 
1147
        state, entry = self.get_state_with_a()
 
1148
        # The file sha1 won't be cached unless the file is old
 
1149
        state.adjust_time(+10)
 
1150
        self.create_and_test_file(state, entry)
 
1151
        os.remove('a')
 
1152
        self.create_and_test_symlink(state, entry)
 
1153
 
 
1154
    def test_update_dir_to_file(self):
 
1155
        """Directory becoming a file updates the entry."""
 
1156
        state, entry = self.get_state_with_a()
 
1157
        # The file sha1 won't be cached unless the file is old
 
1158
        state.adjust_time(+10)
 
1159
        self.create_and_test_dir(state, entry)
 
1160
        os.rmdir('a')
 
1161
        self.create_and_test_file(state, entry)
 
1162
 
 
1163
    def test_update_dir_to_symlink(self):
 
1164
        """Directory becomes a symlink"""
 
1165
        self.requireFeature(tests.SymlinkFeature)
 
1166
        state, entry = self.get_state_with_a()
 
1167
        # The symlink target won't be cached if it isn't old
 
1168
        state.adjust_time(+10)
 
1169
        self.create_and_test_dir(state, entry)
 
1170
        os.rmdir('a')
 
1171
        self.create_and_test_symlink(state, entry)
 
1172
 
 
1173
    def test_update_symlink_to_file(self):
 
1174
        """Symlink becomes a file"""
 
1175
        self.requireFeature(tests.SymlinkFeature)
 
1176
        state, entry = self.get_state_with_a()
 
1177
        # The symlink and file info won't be cached unless old
 
1178
        state.adjust_time(+10)
 
1179
        self.create_and_test_symlink(state, entry)
 
1180
        os.remove('a')
 
1181
        self.create_and_test_file(state, entry)
 
1182
 
 
1183
    def test_update_symlink_to_dir(self):
 
1184
        """Symlink becomes a directory"""
 
1185
        self.requireFeature(tests.SymlinkFeature)
 
1186
        state, entry = self.get_state_with_a()
 
1187
        # The symlink target won't be cached if it isn't old
 
1188
        state.adjust_time(+10)
 
1189
        self.create_and_test_symlink(state, entry)
 
1190
        os.remove('a')
 
1191
        self.create_and_test_dir(state, entry)
 
1192
 
 
1193
    def test__is_executable_win32(self):
 
1194
        state, entry = self.get_state_with_a()
 
1195
        self.build_tree(['a'])
 
1196
 
 
1197
        # Make sure we are using the win32 implementation of _is_executable
 
1198
        state._is_executable = state._is_executable_win32
 
1199
 
 
1200
        # The file on disk is not executable, but we are marking it as though
 
1201
        # it is. With _is_executable_win32 we ignore what is on disk.
 
1202
        entry[1][0] = ('f', '', 0, True, dirstate.DirState.NULLSTAT)
 
1203
 
 
1204
        stat_value = os.lstat('a')
 
1205
        packed_stat = dirstate.pack_stat(stat_value)
 
1206
 
 
1207
        state.adjust_time(-10) # Make sure everything is new
 
1208
        self.update_entry(state, entry, abspath='a', stat_value=stat_value)
 
1209
 
 
1210
        # The row is updated, but the executable bit stays set.
 
1211
        self.assertEqual([('f', '', 14, True, dirstate.DirState.NULLSTAT)],
 
1212
                         entry[1])
 
1213
 
 
1214
        # Make the disk object look old enough to cache (but it won't cache the
 
1215
        # sha as it is a new file).
 
1216
        state.adjust_time(+20)
 
1217
        digest = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
 
1218
        self.update_entry(state, entry, abspath='a', stat_value=stat_value)
 
1219
        self.assertEqual([('f', '', 14, True, dirstate.DirState.NULLSTAT)],
 
1220
            entry[1])
 
1221
 
 
1222
    def _prepare_tree(self):
 
1223
        # Create a tree
 
1224
        text = 'Hello World\n'
 
1225
        tree = self.make_branch_and_tree('tree')
 
1226
        self.build_tree_contents([('tree/a file', text)])
 
1227
        tree.add('a file', 'a-file-id')
 
1228
        # Note: dirstate does not sha prior to the first commit
 
1229
        # so commit now in order for the test to work
 
1230
        tree.commit('first')
 
1231
        return tree, text
 
1232
 
 
1233
    def test_sha1provider_sha1_used(self):
 
1234
        tree, text = self._prepare_tree()
 
1235
        state = dirstate.DirState.from_tree(tree, 'dirstate',
 
1236
            UppercaseSHA1Provider())
 
1237
        self.addCleanup(state.unlock)
 
1238
        expected_sha = osutils.sha_string(text.upper() + "foo")
 
1239
        entry = state._get_entry(0, path_utf8='a file')
 
1240
        state._sha_cutoff_time()
 
1241
        state._cutoff_time += 10
 
1242
        sha1 = self.update_entry(state, entry, 'tree/a file',
 
1243
                                 os.lstat('tree/a file'))
 
1244
        self.assertEqual(expected_sha, sha1)
 
1245
 
 
1246
    def test_sha1provider_stat_and_sha1_used(self):
 
1247
        tree, text = self._prepare_tree()
 
1248
        tree.lock_write()
 
1249
        self.addCleanup(tree.unlock)
 
1250
        state = tree._current_dirstate()
 
1251
        state._sha1_provider = UppercaseSHA1Provider()
 
1252
        # If we used the standard provider, it would look like nothing has
 
1253
        # changed
 
1254
        file_ids_changed = [change[0] for change
 
1255
                            in tree.iter_changes(tree.basis_tree())]
 
1256
        self.assertEqual(['a-file-id'], file_ids_changed)
 
1257
 
 
1258
 
 
1259
class UppercaseSHA1Provider(dirstate.SHA1Provider):
 
1260
    """A custom SHA1Provider."""
 
1261
 
 
1262
    def sha1(self, abspath):
 
1263
        return self.stat_and_sha1(abspath)[1]
 
1264
 
 
1265
    def stat_and_sha1(self, abspath):
 
1266
        file_obj = file(abspath, 'rb')
 
1267
        try:
 
1268
            statvalue = os.fstat(file_obj.fileno())
 
1269
            text = ''.join(file_obj.readlines())
 
1270
            sha1 = osutils.sha_string(text.upper() + "foo")
 
1271
        finally:
 
1272
            file_obj.close()
 
1273
        return statvalue, sha1
 
1274
 
 
1275
 
 
1276
class TestProcessEntry(test_dirstate.TestCaseWithDirState):
 
1277
 
 
1278
    # Set by load_tests
 
1279
    _process_entry = None
 
1280
 
 
1281
    def setUp(self):
 
1282
        super(TestProcessEntry, self).setUp()
 
1283
        orig = dirstate._process_entry
 
1284
        def cleanup():
 
1285
            dirstate._process_entry = orig
 
1286
        self.addCleanup(cleanup)
 
1287
        dirstate._process_entry = self._process_entry
 
1288
 
 
1289
    def assertChangedFileIds(self, expected, tree):
 
1290
        tree.lock_read()
 
1291
        try:
 
1292
            file_ids = [info[0] for info
 
1293
                        in tree.iter_changes(tree.basis_tree())]
 
1294
        finally:
 
1295
            tree.unlock()
 
1296
        self.assertEqual(sorted(expected), sorted(file_ids))
 
1297
 
 
1298
    def test_exceptions_raised(self):
 
1299
        # This is a direct test of bug #495023, it relies on osutils.is_inside
 
1300
        # getting called in an inner function. Which makes it a bit brittle,
 
1301
        # but at least it does reproduce the bug.
 
1302
        def is_inside_raises(*args, **kwargs):
 
1303
            raise RuntimeError('stop this')
 
1304
        tree = self.make_branch_and_tree('tree')
 
1305
        self.build_tree(['tree/file', 'tree/dir/', 'tree/dir/sub',
 
1306
                         'tree/dir2/', 'tree/dir2/sub2'])
 
1307
        tree.add(['file', 'dir', 'dir/sub', 'dir2', 'dir2/sub2'])
 
1308
        tree.commit('first commit')
 
1309
        tree.lock_read()
 
1310
        self.addCleanup(tree.unlock)
 
1311
        basis_tree = tree.basis_tree()
 
1312
        orig = osutils.is_inside
 
1313
        self.addCleanup(setattr, osutils, 'is_inside', orig)
 
1314
        osutils.is_inside = is_inside_raises
 
1315
        self.assertListRaises(RuntimeError, tree.iter_changes, basis_tree)
 
1316
 
 
1317
    def test_simple_changes(self):
 
1318
        tree = self.make_branch_and_tree('tree')
 
1319
        self.build_tree(['tree/file'])
 
1320
        tree.add(['file'], ['file-id'])
 
1321
        self.assertChangedFileIds([tree.get_root_id(), 'file-id'], tree)
 
1322
        tree.commit('one')
 
1323
        self.assertChangedFileIds([], tree)
 
1324
 
 
1325
    def test_sha1provider_stat_and_sha1_used(self):
 
1326
        tree = self.make_branch_and_tree('tree')
 
1327
        self.build_tree(['tree/file'])
 
1328
        tree.add(['file'], ['file-id'])
 
1329
        tree.commit('one')
 
1330
        tree.lock_write()
 
1331
        self.addCleanup(tree.unlock)
 
1332
        state = tree._current_dirstate()
 
1333
        state._sha1_provider = UppercaseSHA1Provider()
 
1334
        self.assertChangedFileIds(['file-id'], tree)
 
1335