← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test__dirstate_helpers.py

  • Committer: Robert Collins
  • Date: 2009-03-27 04:10:25 UTC
  • mfrom: (4208 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4216.
  • Revision ID: robertc@robertcollins.net-20090327041025-rgutx4q03xo4pq6l
Resolve NEWS conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test__dirstate_helpers.py
1
 
# Copyright (C) 2007-2011 Canonical Ltd
 
1
# Copyright (C) 2007, 2008 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
27
27
    tests,
28
28
    )
29
29
from bzrlib.tests import (
30
 
    test_dirstate,
31
 
    )
32
 
from bzrlib.tests.test_osutils import dir_reader_scenarios
33
 
from bzrlib.tests.scenarios import (
34
 
    load_tests_apply_scenarios,
35
 
    multiply_scenarios,
36
 
    )
37
 
 
38
 
 
39
 
load_tests = load_tests_apply_scenarios
40
 
 
41
 
 
42
 
compiled_dirstate_helpers_feature = tests.ModuleAvailableFeature(
43
 
    'bzrlib._dirstate_helpers_pyx')
44
 
 
45
 
 
46
 
# FIXME: we should also parametrize against SHA1Provider !
47
 
 
48
 
ue_scenarios = [('dirstate_Python',
49
 
    {'update_entry': dirstate.py_update_entry})]
50
 
if compiled_dirstate_helpers_feature.available():
51
 
    update_entry = compiled_dirstate_helpers_feature.module.update_entry
52
 
    ue_scenarios.append(('dirstate_Pyrex', {'update_entry': update_entry}))
53
 
 
54
 
pe_scenarios = [('dirstate_Python',
55
 
    {'_process_entry': dirstate.ProcessEntryPython})]
56
 
if compiled_dirstate_helpers_feature.available():
57
 
    process_entry = compiled_dirstate_helpers_feature.module.ProcessEntryC
58
 
    pe_scenarios.append(('dirstate_Pyrex', {'_process_entry': process_entry}))
 
30
        SymlinkFeature,
 
31
        )
 
32
from bzrlib.tests import test_dirstate
 
33
 
 
34
 
 
35
class _CompiledDirstateHelpersFeature(tests.Feature):
 
36
    def _probe(self):
 
37
        try:
 
38
            import bzrlib._dirstate_helpers_c
 
39
        except ImportError:
 
40
            return False
 
41
        return True
 
42
 
 
43
    def feature_name(self):
 
44
        return 'bzrlib._dirstate_helpers_c'
 
45
 
 
46
CompiledDirstateHelpersFeature = _CompiledDirstateHelpersFeature()
59
47
 
60
48
 
61
49
class TestBisectPathMixin(object):
214
202
 
215
203
 
216
204
class TestBisectPathLeft(tests.TestCase, TestBisectPathMixin):
217
 
    """Run all Bisect Path tests against _bisect_path_left."""
 
205
    """Run all Bisect Path tests against _bisect_path_left_py."""
218
206
 
219
207
    def get_bisect_path(self):
220
 
        from bzrlib._dirstate_helpers_py import _bisect_path_left
221
 
        return _bisect_path_left
 
208
        from bzrlib._dirstate_helpers_py import _bisect_path_left_py
 
209
        return _bisect_path_left_py
222
210
 
223
211
    def get_bisect(self):
224
212
        return bisect.bisect_left, 0
225
213
 
226
214
 
227
215
class TestCompiledBisectPathLeft(TestBisectPathLeft):
228
 
    """Run all Bisect Path tests against _bisect_path_lect"""
 
216
    """Run all Bisect Path tests against _bisect_path_right_c"""
229
217
 
230
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
218
    _test_needs_features = [CompiledDirstateHelpersFeature]
231
219
 
232
220
    def get_bisect_path(self):
233
 
        from bzrlib._dirstate_helpers_pyx import _bisect_path_left
234
 
        return _bisect_path_left
 
221
        from bzrlib._dirstate_helpers_c import _bisect_path_left_c
 
222
        return _bisect_path_left_c
235
223
 
236
224
 
237
225
class TestBisectPathRight(tests.TestCase, TestBisectPathMixin):
238
 
    """Run all Bisect Path tests against _bisect_path_right"""
 
226
    """Run all Bisect Path tests against _bisect_path_right_py"""
239
227
 
240
228
    def get_bisect_path(self):
241
 
        from bzrlib._dirstate_helpers_py import _bisect_path_right
242
 
        return _bisect_path_right
 
229
        from bzrlib._dirstate_helpers_py import _bisect_path_right_py
 
230
        return _bisect_path_right_py
243
231
 
244
232
    def get_bisect(self):
245
233
        return bisect.bisect_right, -1
246
234
 
247
235
 
248
236
class TestCompiledBisectPathRight(TestBisectPathRight):
249
 
    """Run all Bisect Path tests against _bisect_path_right"""
 
237
    """Run all Bisect Path tests against _bisect_path_right_c"""
250
238
 
251
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
239
    _test_needs_features = [CompiledDirstateHelpersFeature]
252
240
 
253
241
    def get_bisect_path(self):
254
 
        from bzrlib._dirstate_helpers_pyx import _bisect_path_right
255
 
        return _bisect_path_right
 
242
        from bzrlib._dirstate_helpers_c import _bisect_path_right_c
 
243
        return _bisect_path_right_c
256
244
 
257
245
 
258
246
class TestBisectDirblock(tests.TestCase):
269
257
 
270
258
    def get_bisect_dirblock(self):
271
259
        """Return an implementation of bisect_dirblock"""
272
 
        from bzrlib._dirstate_helpers_py import bisect_dirblock
273
 
        return bisect_dirblock
 
260
        from bzrlib._dirstate_helpers_py import bisect_dirblock_py
 
261
        return bisect_dirblock_py
274
262
 
275
263
    def assertBisect(self, dirblocks, split_dirblocks, path, *args, **kwargs):
276
264
        """Assert that bisect_split works like bisect_left on the split paths.
360
348
    compiled version.
361
349
    """
362
350
 
363
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
351
    _test_needs_features = [CompiledDirstateHelpersFeature]
364
352
 
365
353
    def get_bisect_dirblock(self):
366
 
        from bzrlib._dirstate_helpers_pyx import bisect_dirblock
367
 
        return bisect_dirblock
 
354
        from bzrlib._dirstate_helpers_c import bisect_dirblock_c
 
355
        return bisect_dirblock_c
368
356
 
369
357
 
370
358
class TestCmpByDirs(tests.TestCase):
379
367
 
380
368
    def get_cmp_by_dirs(self):
381
369
        """Get a specific implementation of cmp_by_dirs."""
382
 
        from bzrlib._dirstate_helpers_py import cmp_by_dirs
383
 
        return cmp_by_dirs
 
370
        from bzrlib._dirstate_helpers_py import cmp_by_dirs_py
 
371
        return cmp_by_dirs_py
384
372
 
385
373
    def assertCmpByDirs(self, expected, str1, str2):
386
374
        """Compare the two strings, in both directions.
482
470
class TestCompiledCmpByDirs(TestCmpByDirs):
483
471
    """Test the pyrex implementation of cmp_by_dirs"""
484
472
 
485
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
473
    _test_needs_features = [CompiledDirstateHelpersFeature]
486
474
 
487
475
    def get_cmp_by_dirs(self):
488
 
        from bzrlib._dirstate_helpers_pyx import cmp_by_dirs
489
 
        return cmp_by_dirs
 
476
        from bzrlib._dirstate_helpers_c import cmp_by_dirs_c
 
477
        return cmp_by_dirs_c
490
478
 
491
479
 
492
480
class TestCmpPathByDirblock(tests.TestCase):
501
489
 
502
490
    def get_cmp_path_by_dirblock(self):
503
491
        """Get a specific implementation of _cmp_path_by_dirblock."""
504
 
        from bzrlib._dirstate_helpers_py import _cmp_path_by_dirblock
505
 
        return _cmp_path_by_dirblock
 
492
        from bzrlib._dirstate_helpers_py import _cmp_path_by_dirblock_py
 
493
        return _cmp_path_by_dirblock_py
506
494
 
507
495
    def assertCmpPathByDirblock(self, paths):
508
496
        """Compare all paths and make sure they evaluate to the correct order.
633
621
class TestCompiledCmpPathByDirblock(TestCmpPathByDirblock):
634
622
    """Test the pyrex implementation of _cmp_path_by_dirblock"""
635
623
 
636
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
624
    _test_needs_features = [CompiledDirstateHelpersFeature]
637
625
 
638
626
    def get_cmp_by_dirs(self):
639
 
        from bzrlib._dirstate_helpers_pyx import _cmp_path_by_dirblock
640
 
        return _cmp_path_by_dirblock
 
627
        from bzrlib._dirstate_helpers_c import _cmp_path_by_dirblock_c
 
628
        return _cmp_path_by_dirblock_c
641
629
 
642
630
 
643
631
class TestMemRChr(tests.TestCase):
644
632
    """Test memrchr functionality"""
645
633
 
646
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
634
    _test_needs_features = [CompiledDirstateHelpersFeature]
647
635
 
648
636
    def assertMemRChr(self, expected, s, c):
649
 
        from bzrlib._dirstate_helpers_pyx import _py_memrchr
 
637
        from bzrlib._dirstate_helpers_c import _py_memrchr
650
638
        self.assertEqual(expected, _py_memrchr(s, c))
651
639
 
652
640
    def test_missing(self):
693
681
    implementation.
694
682
    """
695
683
 
696
 
    # inherits scenarios from test_dirstate
697
 
 
698
684
    def get_read_dirblocks(self):
699
 
        from bzrlib._dirstate_helpers_py import _read_dirblocks
700
 
        return _read_dirblocks
 
685
        from bzrlib._dirstate_helpers_py import _read_dirblocks_py
 
686
        return _read_dirblocks_py
701
687
 
702
688
    def test_smoketest(self):
703
689
        """Make sure that we can create and read back a simple file."""
713
699
 
714
700
    def test_trailing_garbage(self):
715
701
        tree, state, expected = self.create_basic_dirstate()
716
 
        # On Unix, we can write extra data as long as we haven't read yet, but
717
 
        # on Win32, if you've opened the file with FILE_SHARE_READ, trying to
718
 
        # open it in append mode will fail.
719
 
        state.unlock()
 
702
        # We can modify the file as long as it hasn't been read yet.
720
703
        f = open('dirstate', 'ab')
721
704
        try:
722
705
            # Add bogus trailing garbage
723
706
            f.write('bogus\n')
724
707
        finally:
725
708
            f.close()
726
 
            state.lock_read()
727
709
        e = self.assertRaises(errors.DirstateCorrupt,
728
710
                              state._read_dirblocks_if_needed)
729
711
        # Make sure we mention the bogus characters in the error
733
715
class TestCompiledReadDirblocks(TestReadDirblocks):
734
716
    """Test the pyrex implementation of _read_dirblocks"""
735
717
 
736
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
718
    _test_needs_features = [CompiledDirstateHelpersFeature]
737
719
 
738
720
    def get_read_dirblocks(self):
739
 
        from bzrlib._dirstate_helpers_pyx import _read_dirblocks
740
 
        return _read_dirblocks
 
721
        from bzrlib._dirstate_helpers_c import _read_dirblocks_c
 
722
        return _read_dirblocks_c
741
723
 
742
724
 
743
725
class TestUsingCompiledIfAvailable(tests.TestCase):
744
726
    """Check that any compiled functions that are available are the default.
745
727
 
746
728
    It is possible to have typos, etc in the import line, such that
747
 
    _dirstate_helpers_pyx is actually available, but the compiled functions are
 
729
    _dirstate_helpers_c is actually available, but the compiled functions are
748
730
    not being used.
749
731
    """
750
732
 
751
733
    def test_bisect_dirblock(self):
752
 
        if compiled_dirstate_helpers_feature.available():
753
 
            from bzrlib._dirstate_helpers_pyx import bisect_dirblock
 
734
        if CompiledDirstateHelpersFeature.available():
 
735
            from bzrlib._dirstate_helpers_c import bisect_dirblock_c
 
736
            self.assertIs(bisect_dirblock_c, dirstate.bisect_dirblock)
754
737
        else:
755
 
            from bzrlib._dirstate_helpers_py import bisect_dirblock
756
 
        self.assertIs(bisect_dirblock, dirstate.bisect_dirblock)
 
738
            from bzrlib._dirstate_helpers_py import bisect_dirblock_py
 
739
            self.assertIs(bisect_dirblock_py, dirstate.bisect_dirblock)
757
740
 
758
741
    def test__bisect_path_left(self):
759
 
        if compiled_dirstate_helpers_feature.available():
760
 
            from bzrlib._dirstate_helpers_pyx import _bisect_path_left
 
742
        if CompiledDirstateHelpersFeature.available():
 
743
            from bzrlib._dirstate_helpers_c import _bisect_path_left_c
 
744
            self.assertIs(_bisect_path_left_c, dirstate._bisect_path_left)
761
745
        else:
762
 
            from bzrlib._dirstate_helpers_py import _bisect_path_left
763
 
        self.assertIs(_bisect_path_left, dirstate._bisect_path_left)
 
746
            from bzrlib._dirstate_helpers_py import _bisect_path_left_py
 
747
            self.assertIs(_bisect_path_left_py, dirstate._bisect_path_left)
764
748
 
765
749
    def test__bisect_path_right(self):
766
 
        if compiled_dirstate_helpers_feature.available():
767
 
            from bzrlib._dirstate_helpers_pyx import _bisect_path_right
 
750
        if CompiledDirstateHelpersFeature.available():
 
751
            from bzrlib._dirstate_helpers_c import _bisect_path_right_c
 
752
            self.assertIs(_bisect_path_right_c, dirstate._bisect_path_right)
768
753
        else:
769
 
            from bzrlib._dirstate_helpers_py import _bisect_path_right
770
 
        self.assertIs(_bisect_path_right, dirstate._bisect_path_right)
 
754
            from bzrlib._dirstate_helpers_py import _bisect_path_right_py
 
755
            self.assertIs(_bisect_path_right_py, dirstate._bisect_path_right)
771
756
 
772
757
    def test_cmp_by_dirs(self):
773
 
        if compiled_dirstate_helpers_feature.available():
774
 
            from bzrlib._dirstate_helpers_pyx import cmp_by_dirs
 
758
        if CompiledDirstateHelpersFeature.available():
 
759
            from bzrlib._dirstate_helpers_c import cmp_by_dirs_c
 
760
            self.assertIs(cmp_by_dirs_c, dirstate.cmp_by_dirs)
775
761
        else:
776
 
            from bzrlib._dirstate_helpers_py import cmp_by_dirs
777
 
        self.assertIs(cmp_by_dirs, dirstate.cmp_by_dirs)
 
762
            from bzrlib._dirstate_helpers_py import cmp_by_dirs_py
 
763
            self.assertIs(cmp_by_dirs_py, dirstate.cmp_by_dirs)
778
764
 
779
765
    def test__read_dirblocks(self):
780
 
        if compiled_dirstate_helpers_feature.available():
781
 
            from bzrlib._dirstate_helpers_pyx import _read_dirblocks
 
766
        if CompiledDirstateHelpersFeature.available():
 
767
            from bzrlib._dirstate_helpers_c import _read_dirblocks_c
 
768
            self.assertIs(_read_dirblocks_c, dirstate._read_dirblocks)
782
769
        else:
783
 
            from bzrlib._dirstate_helpers_py import _read_dirblocks
784
 
        self.assertIs(_read_dirblocks, dirstate._read_dirblocks)
 
770
            from bzrlib._dirstate_helpers_py import _read_dirblocks_py
 
771
            self.assertIs(_read_dirblocks_py, dirstate._read_dirblocks)
785
772
 
786
773
    def test_update_entry(self):
787
 
        if compiled_dirstate_helpers_feature.available():
788
 
            from bzrlib._dirstate_helpers_pyx import update_entry
 
774
        if CompiledDirstateHelpersFeature.available():
 
775
            from bzrlib._dirstate_helpers_c import update_entry
 
776
            self.assertIs(update_entry, dirstate.update_entry)
789
777
        else:
790
 
            from bzrlib.dirstate import update_entry
791
 
        self.assertIs(update_entry, dirstate.update_entry)
 
778
            from bzrlib.dirstate import py_update_entry
 
779
            self.assertIs(py_update_entry, dirstate.py_update_entry)
792
780
 
793
781
    def test_process_entry(self):
794
 
        if compiled_dirstate_helpers_feature.available():
795
 
            from bzrlib._dirstate_helpers_pyx import ProcessEntryC
 
782
        if CompiledDirstateHelpersFeature.available():
 
783
            from bzrlib._dirstate_helpers_c import ProcessEntryC
796
784
            self.assertIs(ProcessEntryC, dirstate._process_entry)
797
785
        else:
798
786
            from bzrlib.dirstate import ProcessEntryPython
802
790
class TestUpdateEntry(test_dirstate.TestCaseWithDirState):
803
791
    """Test the DirState.update_entry functions"""
804
792
 
805
 
    scenarios = multiply_scenarios(
806
 
        dir_reader_scenarios(), ue_scenarios)
807
 
 
808
 
    # Set by load_tests
809
 
    update_entry = None
810
 
 
811
 
    def setUp(self):
812
 
        super(TestUpdateEntry, self).setUp()
813
 
        self.overrideAttr(dirstate, 'update_entry', self.update_entry)
814
 
 
815
793
    def get_state_with_a(self):
816
794
        """Create a DirState tracking a single object named 'a'"""
817
795
        state = test_dirstate.InstrumentedDirState.initialize('dirstate')
818
796
        self.addCleanup(state.unlock)
819
797
        state.add('a', 'a-id', 'file', None, '')
820
798
        entry = state._get_entry(0, path_utf8='a')
 
799
        self.set_update_entry()
821
800
        return state, entry
822
801
 
 
802
    def set_update_entry(self):
 
803
        self.update_entry = dirstate.py_update_entry
 
804
 
823
805
    def test_observed_sha1_cachable(self):
824
806
        state, entry = self.get_state_with_a()
825
 
        state.save()
826
807
        atime = time.time() - 10
827
808
        self.build_tree(['a'])
828
 
        statvalue = test_dirstate._FakeStat.from_stat(os.lstat('a'))
829
 
        statvalue.st_mtime = statvalue.st_ctime = atime
830
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
831
 
                         state._dirblock_state)
 
809
        statvalue = os.lstat('a')
 
810
        statvalue = test_dirstate._FakeStat(statvalue.st_size, atime, atime,
 
811
            statvalue.st_dev, statvalue.st_ino, statvalue.st_mode)
832
812
        state._observed_sha1(entry, "foo", statvalue)
833
813
        self.assertEqual('foo', entry[1][0][1])
834
814
        packed_stat = dirstate.pack_stat(statvalue)
835
815
        self.assertEqual(packed_stat, entry[1][0][4])
836
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
837
 
                         state._dirblock_state)
838
816
 
839
817
    def test_observed_sha1_not_cachable(self):
840
818
        state, entry = self.get_state_with_a()
841
 
        state.save()
842
819
        oldval = entry[1][0][1]
843
820
        oldstat = entry[1][0][4]
844
821
        self.build_tree(['a'])
845
822
        statvalue = os.lstat('a')
846
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
847
 
                         state._dirblock_state)
848
823
        state._observed_sha1(entry, "foo", statvalue)
849
824
        self.assertEqual(oldval, entry[1][0][1])
850
825
        self.assertEqual(oldstat, entry[1][0][4])
851
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
852
 
                         state._dirblock_state)
853
826
 
854
827
    def test_update_entry(self):
855
828
        state, _ = self.get_state_with_a()
880
853
                                          stat_value=stat_value)
881
854
        self.assertEqual(None, link_or_sha1)
882
855
 
883
 
        # The dirblock entry should not have computed or cached the file's
884
 
        # sha1, but it did update the files' st_size. However, this is not
885
 
        # worth writing a dirstate file for, so we leave the state UNMODIFIED
 
856
        # The dirblock entry should not have cached the file's sha1 (too new)
886
857
        self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
887
858
                         entry[1][0])
888
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
859
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
889
860
                         state._dirblock_state)
890
861
        mode = stat_value.st_mode
891
862
        self.assertEqual([('is_exec', mode, False)], state._log)
894
865
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
895
866
                         state._dirblock_state)
896
867
 
897
 
        # Roll the clock back so the file is guaranteed to look too new. We
898
 
        # should still not compute the sha1.
 
868
        # If we do it again right away, we don't know if the file has changed
 
869
        # so we will re-read the file. Roll the clock back so the file is
 
870
        # guaranteed to look too new.
899
871
        state.adjust_time(-10)
900
872
        del state._log[:]
901
873
 
903
875
                                          stat_value=stat_value)
904
876
        self.assertEqual([('is_exec', mode, False)], state._log)
905
877
        self.assertEqual(None, link_or_sha1)
906
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
878
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
907
879
                         state._dirblock_state)
908
880
        self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
909
881
                         entry[1][0])
919
891
        self.assertEqual([('is_exec', mode, False)], state._log)
920
892
        self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
921
893
                         entry[1][0])
922
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
923
 
                         state._dirblock_state)
924
894
 
925
895
        # If the file is no longer new, and the clock has been moved forward
926
896
        # sufficiently, it will cache the sha.
951
921
 
952
922
    def test_update_entry_symlink(self):
953
923
        """Update entry should read symlinks."""
954
 
        self.requireFeature(tests.SymlinkFeature)
 
924
        self.requireFeature(SymlinkFeature)
955
925
        state, entry = self.get_state_with_a()
956
926
        state.save()
957
927
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
968
938
        # Dirblock is not updated (the link is too new)
969
939
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
970
940
                         entry[1])
971
 
        # The file entry turned into a symlink, that is considered
972
 
        # HASH modified worthy.
973
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
 
941
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
974
942
                         state._dirblock_state)
975
943
 
976
944
        # Because the stat_value looks new, we should re-read the target
977
 
        del state._log[:]
978
945
        link_or_sha1 = self.update_entry(state, entry, abspath='a',
979
946
                                          stat_value=stat_value)
980
947
        self.assertEqual('target', link_or_sha1)
981
 
        self.assertEqual([('read_link', 'a', '')], state._log)
 
948
        self.assertEqual([('read_link', 'a', ''),
 
949
                          ('read_link', 'a', ''),
 
950
                         ], state._log)
982
951
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
983
952
                         entry[1])
984
 
        state.save()
985
953
        state.adjust_time(+20) # Skip into the future, all files look old
986
 
        del state._log[:]
987
954
        link_or_sha1 = self.update_entry(state, entry, abspath='a',
988
955
                                          stat_value=stat_value)
989
 
        # The symlink stayed a symlink. So while it is new enough to cache, we
990
 
        # don't bother setting the flag, because it is not really worth saving
991
 
        # (when we stat the symlink, we'll have paged in the target.)
992
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
993
 
                         state._dirblock_state)
994
956
        self.assertEqual('target', link_or_sha1)
995
957
        # We need to re-read the link because only now can we cache it
996
 
        self.assertEqual([('read_link', 'a', '')], state._log)
 
958
        self.assertEqual([('read_link', 'a', ''),
 
959
                          ('read_link', 'a', ''),
 
960
                          ('read_link', 'a', ''),
 
961
                         ], state._log)
997
962
        self.assertEqual([('l', 'target', 6, False, packed_stat)],
998
963
                         entry[1])
999
964
 
1000
 
        del state._log[:]
1001
965
        # Another call won't re-read the link
1002
 
        self.assertEqual([], state._log)
 
966
        self.assertEqual([('read_link', 'a', ''),
 
967
                          ('read_link', 'a', ''),
 
968
                          ('read_link', 'a', ''),
 
969
                         ], state._log)
1003
970
        link_or_sha1 = self.update_entry(state, entry, abspath='a',
1004
971
                                          stat_value=stat_value)
1005
972
        self.assertEqual('target', link_or_sha1)
1020
987
        self.build_tree(['a/'])
1021
988
        state.adjust_time(+20)
1022
989
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1023
 
        # a/ used to be a file, but is now a directory, worth saving
1024
990
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1025
991
                         state._dirblock_state)
1026
992
        state.save()
1027
993
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1028
994
                         state._dirblock_state)
1029
 
        # No changes to a/ means not worth saving.
1030
 
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1031
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1032
 
                         state._dirblock_state)
1033
 
        # Change the last-modified time for the directory
1034
 
        t = time.time() - 100.0
1035
 
        try:
1036
 
            os.utime('a', (t, t))
1037
 
        except OSError:
1038
 
            # It looks like Win32 + FAT doesn't allow to change times on a dir.
1039
 
            raise tests.TestSkipped("can't update mtime of a dir on FAT")
1040
 
        saved_packed_stat = entry[1][0][-1]
1041
 
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1042
 
        # We *do* go ahead and update the information in the dirblocks, but we
1043
 
        # don't bother setting IN_MEMORY_MODIFIED because it is trivial to
1044
 
        # recompute.
1045
 
        self.assertNotEqual(saved_packed_stat, entry[1][0][-1])
 
995
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1046
996
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1047
997
                         state._dirblock_state)
1048
998
 
1072
1022
                         state._dirblock_state)
1073
1023
 
1074
1024
    def test_update_entry_tree_reference(self):
 
1025
        self.set_update_entry()
1075
1026
        state = test_dirstate.InstrumentedDirState.initialize('dirstate')
1076
1027
        self.addCleanup(state.unlock)
1077
1028
        state.add('r', 'r-id', 'tree-reference', None, '')
1113
1064
 
1114
1065
        return packed_stat
1115
1066
 
1116
 
    # FIXME: Add unicode version
1117
1067
    def create_and_test_symlink(self, state, entry):
1118
1068
        """Create a symlink at 'a' and verify the state finds it.
1119
1069
 
1148
1098
 
1149
1099
    def test_update_file_to_symlink(self):
1150
1100
        """File becomes a symlink"""
1151
 
        self.requireFeature(tests.SymlinkFeature)
 
1101
        self.requireFeature(SymlinkFeature)
1152
1102
        state, entry = self.get_state_with_a()
1153
1103
        # The file sha1 won't be cached unless the file is old
1154
1104
        state.adjust_time(+10)
1167
1117
 
1168
1118
    def test_update_dir_to_symlink(self):
1169
1119
        """Directory becomes a symlink"""
1170
 
        self.requireFeature(tests.SymlinkFeature)
 
1120
        self.requireFeature(SymlinkFeature)
1171
1121
        state, entry = self.get_state_with_a()
1172
1122
        # The symlink target won't be cached if it isn't old
1173
1123
        state.adjust_time(+10)
1177
1127
 
1178
1128
    def test_update_symlink_to_file(self):
1179
1129
        """Symlink becomes a file"""
1180
 
        self.requireFeature(tests.SymlinkFeature)
 
1130
        self.requireFeature(SymlinkFeature)
1181
1131
        state, entry = self.get_state_with_a()
1182
1132
        # The symlink and file info won't be cached unless old
1183
1133
        state.adjust_time(+10)
1187
1137
 
1188
1138
    def test_update_symlink_to_dir(self):
1189
1139
        """Symlink becomes a directory"""
1190
 
        self.requireFeature(tests.SymlinkFeature)
 
1140
        self.requireFeature(SymlinkFeature)
1191
1141
        state, entry = self.get_state_with_a()
1192
1142
        # The symlink target won't be cached if it isn't old
1193
1143
        state.adjust_time(+10)
1216
1166
        self.assertEqual([('f', '', 14, True, dirstate.DirState.NULLSTAT)],
1217
1167
                         entry[1])
1218
1168
 
1219
 
        # Make the disk object look old enough to cache (but it won't cache the
1220
 
        # sha as it is a new file).
 
1169
        # Make the disk object look old enough to cache (but it won't cache the sha
 
1170
        # as it is a new file).
1221
1171
        state.adjust_time(+20)
1222
1172
        digest = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
1223
1173
        self.update_entry(state, entry, abspath='a', stat_value=stat_value)
1244
1194
        entry = state._get_entry(0, path_utf8='a file')
1245
1195
        state._sha_cutoff_time()
1246
1196
        state._cutoff_time += 10
1247
 
        sha1 = self.update_entry(state, entry, 'tree/a file',
1248
 
                                 os.lstat('tree/a file'))
 
1197
        sha1 = dirstate.update_entry(state, entry, 'tree/a file',
 
1198
            os.lstat('tree/a file'))
1249
1199
        self.assertEqual(expected_sha, sha1)
1250
1200
 
1251
1201
    def test_sha1provider_stat_and_sha1_used(self):
1256
1206
        state._sha1_provider = UppercaseSHA1Provider()
1257
1207
        # If we used the standard provider, it would look like nothing has
1258
1208
        # changed
1259
 
        file_ids_changed = [change[0] for change
1260
 
                            in tree.iter_changes(tree.basis_tree())]
 
1209
        file_ids_changed = [change[0] for change 
 
1210
                in tree.iter_changes(tree.basis_tree())]
1261
1211
        self.assertEqual(['a-file-id'], file_ids_changed)
1262
1212
 
1263
1213
 
1278
1228
        return statvalue, sha1
1279
1229
 
1280
1230
 
1281
 
class TestProcessEntry(test_dirstate.TestCaseWithDirState):
1282
 
 
1283
 
    scenarios = multiply_scenarios(dir_reader_scenarios(), pe_scenarios)
1284
 
 
1285
 
    # Set by load_tests
1286
 
    _process_entry = None
 
1231
class TestCompiledUpdateEntry(TestUpdateEntry):
 
1232
    """Test the pyrex implementation of _read_dirblocks"""
 
1233
 
 
1234
    _test_needs_features = [CompiledDirstateHelpersFeature]
 
1235
 
 
1236
    def set_update_entry(self):
 
1237
        from bzrlib._dirstate_helpers_c import update_entry
 
1238
        self.update_entry = update_entry
 
1239
 
 
1240
 
 
1241
class TestProcessEntryPython(test_dirstate.TestCaseWithDirState):
1287
1242
 
1288
1243
    def setUp(self):
1289
 
        super(TestProcessEntry, self).setUp()
1290
 
        self.overrideAttr(dirstate, '_process_entry', self._process_entry)
 
1244
        super(TestProcessEntryPython, self).setUp()
 
1245
        self.setup_process_entry()
 
1246
 
 
1247
    def setup_process_entry(self):
 
1248
        from bzrlib import dirstate
 
1249
        orig = dirstate._process_entry
 
1250
        def cleanup():
 
1251
            dirstate._process_entry = orig
 
1252
        self.addCleanup(cleanup)
 
1253
        dirstate._process_entry = dirstate.ProcessEntryPython
1291
1254
 
1292
1255
    def assertChangedFileIds(self, expected, tree):
1293
1256
        tree.lock_read()
1298
1261
            tree.unlock()
1299
1262
        self.assertEqual(sorted(expected), sorted(file_ids))
1300
1263
 
1301
 
    def test_exceptions_raised(self):
1302
 
        # This is a direct test of bug #495023, it relies on osutils.is_inside
1303
 
        # getting called in an inner function. Which makes it a bit brittle,
1304
 
        # but at least it does reproduce the bug.
1305
 
        tree = self.make_branch_and_tree('tree')
1306
 
        self.build_tree(['tree/file', 'tree/dir/', 'tree/dir/sub',
1307
 
                         'tree/dir2/', 'tree/dir2/sub2'])
1308
 
        tree.add(['file', 'dir', 'dir/sub', 'dir2', 'dir2/sub2'])
1309
 
        tree.commit('first commit')
1310
 
        tree.lock_read()
1311
 
        self.addCleanup(tree.unlock)
1312
 
        basis_tree = tree.basis_tree()
1313
 
        def is_inside_raises(*args, **kwargs):
1314
 
            raise RuntimeError('stop this')
1315
 
        self.overrideAttr(osutils, 'is_inside', is_inside_raises)
1316
 
        self.assertListRaises(RuntimeError, tree.iter_changes, basis_tree)
1317
 
 
1318
1264
    def test_simple_changes(self):
1319
1265
        tree = self.make_branch_and_tree('tree')
1320
1266
        self.build_tree(['tree/file'])
1334
1280
        state._sha1_provider = UppercaseSHA1Provider()
1335
1281
        self.assertChangedFileIds(['file-id'], tree)
1336
1282
 
 
1283
 
 
1284
class TestProcessEntryC(TestProcessEntryPython):
 
1285
    _test_needs_features = [CompiledDirstateHelpersFeature]
 
1286
 
 
1287
    def setup_process_entry(self):
 
1288
        from bzrlib import _dirstate_helpers_c
 
1289
        orig = dirstate._process_entry
 
1290
        def cleanup():
 
1291
            dirstate._process_entry = orig
 
1292
        self.addCleanup(cleanup)
 
1293
        dirstate._process_entry = _dirstate_helpers_c.ProcessEntryC
 
1294