← 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: Jelmer Vernooij
  • Date: 2011-05-01 21:02:50 UTC
  • mto: This revision was merged to the branch mainline in revision 5842.
  • Revision ID: jelmer@samba.org-20110501210250-24jq6hrxxc9psvzf
Actually use branch format 5 in branch format 5 test.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test__dirstate_helpers.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2007-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
28
28
    )
29
29
from bzrlib.tests import (
30
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
 
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
39
40
 
40
41
 
41
42
compiled_dirstate_helpers_feature = tests.ModuleAvailableFeature(
42
 
                                'bzrlib._dirstate_helpers_pyx')
43
 
 
44
 
 
45
 
def load_tests(basic_tests, module, loader):
46
 
    # FIXME: we should also parametrize against SHA1Provider !
47
 
    suite = loader.suiteClass()
48
 
    remaining_tests = basic_tests
49
 
 
50
 
    dir_reader_scenarios = test_osutils.dir_reader_scenarios()
51
 
 
52
 
    ue_scenarios = [('dirstate_Python',
53
 
                     {'update_entry': dirstate.py_update_entry})]
54
 
    if compiled_dirstate_helpers_feature.available():
55
 
        update_entry = compiled_dirstate_helpers_feature.module.update_entry
56
 
        pyrex_scenario = ('dirstate_Pyrex', {'update_entry': update_entry})
57
 
        ue_scenarios.append(pyrex_scenario)
58
 
    process_entry_tests, remaining_tests = tests.split_suite_by_condition(
59
 
        remaining_tests, tests.condition_isinstance(TestUpdateEntry))
60
 
    tests.multiply_tests(process_entry_tests,
61
 
                         tests.multiply_scenarios(dir_reader_scenarios,
62
 
                                                  ue_scenarios),
63
 
                         suite)
64
 
 
65
 
    pe_scenarios = [('dirstate_Python',
66
 
                     {'_process_entry': dirstate.ProcessEntryPython})]
67
 
    if compiled_dirstate_helpers_feature.available():
68
 
        process_entry = compiled_dirstate_helpers_feature.module.ProcessEntryC
69
 
        pyrex_scenario = ('dirstate_Pyrex', {'_process_entry': process_entry})
70
 
        pe_scenarios.append(pyrex_scenario)
71
 
    process_entry_tests, remaining_tests = tests.split_suite_by_condition(
72
 
        remaining_tests, tests.condition_isinstance(TestProcessEntry))
73
 
    tests.multiply_tests(process_entry_tests,
74
 
                         tests.multiply_scenarios(dir_reader_scenarios,
75
 
                                                  pe_scenarios),
76
 
                         suite)
77
 
 
78
 
    dir_reader_tests, remaining_tests = tests.split_suite_by_condition(
79
 
        remaining_tests, tests.condition_isinstance(
80
 
            test_dirstate.TestCaseWithDirState))
81
 
    tests.multiply_tests(dir_reader_tests, dir_reader_scenarios, suite)
82
 
    suite.addTest(remaining_tests)
83
 
 
84
 
    return suite
 
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}))
85
59
 
86
60
 
87
61
class TestBisectPathMixin(object):
719
693
    implementation.
720
694
    """
721
695
 
 
696
    # inherits scenarios from test_dirstate
 
697
 
722
698
    def get_read_dirblocks(self):
723
699
        from bzrlib._dirstate_helpers_py import _read_dirblocks
724
700
        return _read_dirblocks
737
713
 
738
714
    def test_trailing_garbage(self):
739
715
        tree, state, expected = self.create_basic_dirstate()
740
 
        # On Linux, we can write extra data as long as we haven't read yet, but
 
716
        # On Unix, we can write extra data as long as we haven't read yet, but
741
717
        # on Win32, if you've opened the file with FILE_SHARE_READ, trying to
742
718
        # open it in append mode will fail.
743
719
        state.unlock()
826
802
class TestUpdateEntry(test_dirstate.TestCaseWithDirState):
827
803
    """Test the DirState.update_entry functions"""
828
804
 
 
805
    scenarios = multiply_scenarios(
 
806
        dir_reader_scenarios(), ue_scenarios)
 
807
 
829
808
    # Set by load_tests
830
809
    update_entry = None
831
810
 
892
871
                                          stat_value=stat_value)
893
872
        self.assertEqual(None, link_or_sha1)
894
873
 
895
 
        # The dirblock entry should not have cached the file's sha1 (too new)
 
874
        # The dirblock entry should not have computed or cached the file's
 
875
        # sha1, but it did update the files' st_size. However, this is not
 
876
        # worth writing a dirstate file for, so we leave the state UNMODIFIED
896
877
        self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
897
878
                         entry[1][0])
898
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
879
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
899
880
                         state._dirblock_state)
900
881
        mode = stat_value.st_mode
901
882
        self.assertEqual([('is_exec', mode, False)], state._log)
904
885
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
905
886
                         state._dirblock_state)
906
887
 
907
 
        # If we do it again right away, we don't know if the file has changed
908
 
        # so we will re-read the file. Roll the clock back so the file is
909
 
        # guaranteed to look too new.
 
888
        # Roll the clock back so the file is guaranteed to look too new. We
 
889
        # should still not compute the sha1.
910
890
        state.adjust_time(-10)
911
891
        del state._log[:]
912
892
 
914
894
                                          stat_value=stat_value)
915
895
        self.assertEqual([('is_exec', mode, False)], state._log)
916
896
        self.assertEqual(None, link_or_sha1)
917
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
897
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
918
898
                         state._dirblock_state)
919
899
        self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
920
900
                         entry[1][0])
930
910
        self.assertEqual([('is_exec', mode, False)], state._log)
931
911
        self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
932
912
                         entry[1][0])
 
913
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
914
                         state._dirblock_state)
933
915
 
934
916
        # If the file is no longer new, and the clock has been moved forward
935
917
        # sufficiently, it will cache the sha.
1026
1008
        self.build_tree(['a/'])
1027
1009
        state.adjust_time(+20)
1028
1010
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1011
        # a/ used to be a file, but is now a directory, worth saving
1029
1012
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1030
1013
                         state._dirblock_state)
1031
1014
        state.save()
1032
1015
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1033
1016
                         state._dirblock_state)
1034
 
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1017
        # No changes to a/ means not worth saving.
 
1018
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1019
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1020
                         state._dirblock_state)
 
1021
        # Change the last-modified time for the directory
 
1022
        t = time.time() - 100.0
 
1023
        os.utime('a', (t, t))
 
1024
        saved_packed_stat = entry[1][0][-1]
 
1025
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1026
        # We *do* go ahead and update the information in the dirblocks, but we
 
1027
        # don't bother setting IN_MEMORY_MODIFIED because it is trivial to
 
1028
        # recompute.
 
1029
        self.assertNotEqual(saved_packed_stat, entry[1][0][-1])
1035
1030
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1036
1031
                         state._dirblock_state)
1037
1032
 
1269
1264
 
1270
1265
class TestProcessEntry(test_dirstate.TestCaseWithDirState):
1271
1266
 
 
1267
    scenarios = multiply_scenarios(dir_reader_scenarios(), pe_scenarios)
 
1268
 
1272
1269
    # Set by load_tests
1273
1270
    _process_entry = None
1274
1271