201
def create_basic_dirstate(self):
202
"""Create a dirstate with a few files and directories.
212
tree = self.make_branch_and_tree('tree')
213
paths = ['a', 'b/', 'b/c', 'b/d/', 'b/d/e', 'b-c', 'f']
214
file_ids = ['a-id', 'b-id', 'c-id', 'd-id', 'e-id', 'b-c-id', 'f-id']
215
self.build_tree(['tree/' + p for p in paths])
216
tree.set_root_id('TREE_ROOT')
217
tree.add([p.rstrip('/') for p in paths], file_ids)
218
tree.commit('initial', rev_id='rev-1')
219
revision_id = 'rev-1'
220
# a_packed_stat = dirstate.pack_stat(os.stat('tree/a'))
221
t = self.get_transport('tree')
222
a_text = t.get_bytes('a')
223
a_sha = osutils.sha_string(a_text)
225
# b_packed_stat = dirstate.pack_stat(os.stat('tree/b'))
226
# c_packed_stat = dirstate.pack_stat(os.stat('tree/b/c'))
227
c_text = t.get_bytes('b/c')
228
c_sha = osutils.sha_string(c_text)
230
# d_packed_stat = dirstate.pack_stat(os.stat('tree/b/d'))
231
# e_packed_stat = dirstate.pack_stat(os.stat('tree/b/d/e'))
232
e_text = t.get_bytes('b/d/e')
233
e_sha = osutils.sha_string(e_text)
235
b_c_text = t.get_bytes('b-c')
236
b_c_sha = osutils.sha_string(b_c_text)
237
b_c_len = len(b_c_text)
238
# f_packed_stat = dirstate.pack_stat(os.stat('tree/f'))
239
f_text = t.get_bytes('f')
240
f_sha = osutils.sha_string(f_text)
242
null_stat = dirstate.DirState.NULLSTAT
244
'':(('', '', 'TREE_ROOT'), [
245
('d', '', 0, False, null_stat),
246
('d', '', 0, False, revision_id),
248
'a':(('', 'a', 'a-id'), [
249
('f', '', 0, False, null_stat),
250
('f', a_sha, a_len, False, revision_id),
252
'b':(('', 'b', 'b-id'), [
253
('d', '', 0, False, null_stat),
254
('d', '', 0, False, revision_id),
256
'b/c':(('b', 'c', 'c-id'), [
257
('f', '', 0, False, null_stat),
258
('f', c_sha, c_len, False, revision_id),
260
'b/d':(('b', 'd', 'd-id'), [
261
('d', '', 0, False, null_stat),
262
('d', '', 0, False, revision_id),
264
'b/d/e':(('b/d', 'e', 'e-id'), [
265
('f', '', 0, False, null_stat),
266
('f', e_sha, e_len, False, revision_id),
268
'b-c':(('', 'b-c', 'b-c-id'), [
269
('f', '', 0, False, null_stat),
270
('f', b_c_sha, b_c_len, False, revision_id),
272
'f':(('', 'f', 'f-id'), [
273
('f', '', 0, False, null_stat),
274
('f', f_sha, f_len, False, revision_id),
277
state = dirstate.DirState.from_tree(tree, 'dirstate')
282
# Use a different object, to make sure nothing is pre-cached in memory.
283
state = dirstate.DirState.on_file('dirstate')
285
self.addCleanup(state.unlock)
286
self.assertEqual(dirstate.DirState.NOT_IN_MEMORY,
287
state._dirblock_state)
288
# This is code is only really tested if we actually have to make more
289
# than one read, so set the page size to something smaller.
290
# We want it to contain about 2.2 records, so that we have a couple
291
# records that we can read per attempt
292
state._bisect_page_size = 200
293
return tree, state, expected
295
def create_duplicated_dirstate(self):
296
"""Create a dirstate with a deleted and added entries.
298
This grabs a basic_dirstate, and then removes and re adds every entry
301
tree, state, expected = self.create_basic_dirstate()
302
# Now we will just remove and add every file so we get an extra entry
303
# per entry. Unversion in reverse order so we handle subdirs
304
tree.unversion(['f-id', 'b-c-id', 'e-id', 'd-id', 'c-id', 'b-id', 'a-id'])
305
tree.add(['a', 'b', 'b/c', 'b/d', 'b/d/e', 'b-c', 'f'],
306
['a-id2', 'b-id2', 'c-id2', 'd-id2', 'e-id2', 'b-c-id2', 'f-id2'])
308
# Update the expected dictionary.
309
for path in ['a', 'b', 'b/c', 'b/d', 'b/d/e', 'b-c', 'f']:
310
orig = expected[path]
312
# This record was deleted in the current tree
313
expected[path] = (orig[0], [dirstate.DirState.NULL_PARENT_DETAILS,
315
new_key = (orig[0][0], orig[0][1], orig[0][2]+'2')
316
# And didn't exist in the basis tree
317
expected[path2] = (new_key, [orig[1][0],
318
dirstate.DirState.NULL_PARENT_DETAILS])
320
# We will replace the 'dirstate' file underneath 'state', but that is
321
# okay as lock as we unlock 'state' first.
324
new_state = dirstate.DirState.from_tree(tree, 'dirstate')
330
# But we need to leave state in a read-lock because we already have
331
# a cleanup scheduled
333
return tree, state, expected
335
def create_renamed_dirstate(self):
336
"""Create a dirstate with a few internal renames.
338
This takes the basic dirstate, and moves the paths around.
340
tree, state, expected = self.create_basic_dirstate()
342
tree.rename_one('a', 'b/g')
344
tree.rename_one('b/d', 'h')
346
old_a = expected['a']
347
expected['a'] = (old_a[0], [('r', 'b/g', 0, False, ''), old_a[1][1]])
348
expected['b/g'] = (('b', 'g', 'a-id'), [old_a[1][0],
349
('r', 'a', 0, False, '')])
350
old_d = expected['b/d']
351
expected['b/d'] = (old_d[0], [('r', 'h', 0, False, ''), old_d[1][1]])
352
expected['h'] = (('', 'h', 'd-id'), [old_d[1][0],
353
('r', 'b/d', 0, False, '')])
355
old_e = expected['b/d/e']
356
expected['b/d/e'] = (old_e[0], [('r', 'h/e', 0, False, ''),
358
expected['h/e'] = (('h', 'e', 'e-id'), [old_e[1][0],
359
('r', 'b/d/e', 0, False, '')])
363
new_state = dirstate.DirState.from_tree(tree, 'dirstate')
370
return tree, state, expected
373
178
class TestTreeToDirState(TestCaseWithDirState):
568
def test_can_save_in_read_lock(self):
569
self.build_tree(['a-file'])
570
state = dirstate.DirState.initialize('dirstate')
572
# No stat and no sha1 sum.
573
state.add('a-file', 'a-file-id', 'file', None, '')
578
# Now open in readonly mode
579
state = dirstate.DirState.on_file('dirstate')
582
entry = state._get_entry(0, path_utf8='a-file')
583
# The current size should be 0 (default)
584
self.assertEqual(0, entry[1][0][2])
585
# We should have a real entry.
586
self.assertNotEqual((None, None), entry)
587
# Make sure everything is old enough
588
state._sha_cutoff_time()
589
state._cutoff_time += 10
590
# Change the file length
591
self.build_tree_contents([('a-file', 'shorter')])
592
sha1sum = dirstate.update_entry(state, entry, 'a-file',
594
# new file, no cached sha:
595
self.assertEqual(None, sha1sum)
597
# The dirblock has been updated
598
self.assertEqual(7, entry[1][0][2])
599
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
600
state._dirblock_state)
603
# Now, since we are the only one holding a lock, we should be able
604
# to save and have it written to disk
609
# Re-open the file, and ensure that the state has been updated.
610
state = dirstate.DirState.on_file('dirstate')
613
entry = state._get_entry(0, path_utf8='a-file')
614
self.assertEqual(7, entry[1][0][2])
618
def test_save_fails_quietly_if_locked(self):
619
"""If dirstate is locked, save will fail without complaining."""
620
self.build_tree(['a-file'])
621
state = dirstate.DirState.initialize('dirstate')
623
# No stat and no sha1 sum.
624
state.add('a-file', 'a-file-id', 'file', None, '')
629
state = dirstate.DirState.on_file('dirstate')
632
entry = state._get_entry(0, path_utf8='a-file')
633
sha1sum = dirstate.update_entry(state, entry, 'a-file',
636
self.assertEqual(None, sha1sum)
637
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
638
state._dirblock_state)
640
# Now, before we try to save, grab another dirstate, and take out a
642
# TODO: jam 20070315 Ideally this would be locked by another
643
# process. To make sure the file is really OS locked.
644
state2 = dirstate.DirState.on_file('dirstate')
647
# This won't actually write anything, because it couldn't grab
648
# a write lock. But it shouldn't raise an error, either.
649
# TODO: jam 20070315 We should probably distinguish between
650
# being dirty because of 'update_entry'. And dirty
651
# because of real modification. So that save() *does*
652
# raise a real error if it fails when we have real
660
# The file on disk should not be modified.
661
state = dirstate.DirState.on_file('dirstate')
664
entry = state._get_entry(0, path_utf8='a-file')
665
self.assertEqual('', entry[1][0][1])
669
def test_save_refuses_if_changes_aborted(self):
670
self.build_tree(['a-file', 'a-dir/'])
671
state = dirstate.DirState.initialize('dirstate')
673
# No stat and no sha1 sum.
674
state.add('a-file', 'a-file-id', 'file', None, '')
679
# The dirstate should include TREE_ROOT and 'a-file' and nothing else
681
('', [(('', '', 'TREE_ROOT'),
682
[('d', '', 0, False, dirstate.DirState.NULLSTAT)])]),
683
('', [(('', 'a-file', 'a-file-id'),
684
[('f', '', 0, False, dirstate.DirState.NULLSTAT)])]),
687
state = dirstate.DirState.on_file('dirstate')
690
state._read_dirblocks_if_needed()
691
self.assertEqual(expected_blocks, state._dirblocks)
693
# Now modify the state, but mark it as inconsistent
694
state.add('a-dir', 'a-dir-id', 'directory', None, '')
695
state._changes_aborted = True
700
state = dirstate.DirState.on_file('dirstate')
703
state._read_dirblocks_if_needed()
704
self.assertEqual(expected_blocks, state._dirblocks)
709
366
class TestDirStateInitialize(TestCaseWithDirState):
758
413
# This will unlock it
759
414
self.check_state_with_reopen(expected_result, state)
761
def test_set_state_from_inventory_preserves_hashcache(self):
762
# https://bugs.launchpad.net/bzr/+bug/146176
763
# set_state_from_inventory should preserve the stat and hash value for
764
# workingtree files that are not changed by the inventory.
766
tree = self.make_branch_and_tree('.')
767
# depends on the default format using dirstate...
770
# make a dirstate with some valid hashcache data
771
# file on disk, but that's not needed for this test
772
foo_contents = 'contents of foo'
773
self.build_tree_contents([('foo', foo_contents)])
774
tree.add('foo', 'foo-id')
776
foo_stat = os.stat('foo')
777
foo_packed = dirstate.pack_stat(foo_stat)
778
foo_sha = osutils.sha_string(foo_contents)
779
foo_size = len(foo_contents)
781
# should not be cached yet, because the file's too fresh
783
(('', 'foo', 'foo-id',),
784
[('f', '', 0, False, dirstate.DirState.NULLSTAT)]),
785
tree._dirstate._get_entry(0, 'foo-id'))
786
# poke in some hashcache information - it wouldn't normally be
787
# stored because it's too fresh
788
tree._dirstate.update_minimal(
789
('', 'foo', 'foo-id'),
790
'f', False, foo_sha, foo_packed, foo_size, 'foo')
791
# now should be cached
793
(('', 'foo', 'foo-id',),
794
[('f', foo_sha, foo_size, False, foo_packed)]),
795
tree._dirstate._get_entry(0, 'foo-id'))
797
# extract the inventory, and add something to it
798
inv = tree._get_inventory()
799
# should see the file we poked in...
800
self.assertTrue(inv.has_id('foo-id'))
801
self.assertTrue(inv.has_filename('foo'))
802
inv.add_path('bar', 'file', 'bar-id')
803
tree._dirstate._validate()
804
# this used to cause it to lose its hashcache
805
tree._dirstate.set_state_from_inventory(inv)
806
tree._dirstate._validate()
812
# now check that the state still has the original hashcache value
813
state = tree._dirstate
815
foo_tuple = state._get_entry(0, path_utf8='foo')
817
(('', 'foo', 'foo-id',),
818
[('f', foo_sha, len(foo_contents), False,
819
dirstate.pack_stat(foo_stat))]),
824
def test_set_state_from_inventory_mixed_paths(self):
825
tree1 = self.make_branch_and_tree('tree1')
826
self.build_tree(['tree1/a/', 'tree1/a/b/', 'tree1/a-b/',
827
'tree1/a/b/foo', 'tree1/a-b/bar'])
830
tree1.add(['a', 'a/b', 'a-b', 'a/b/foo', 'a-b/bar'],
831
['a-id', 'b-id', 'a-b-id', 'foo-id', 'bar-id'])
832
tree1.commit('rev1', rev_id='rev1')
833
root_id = tree1.get_root_id()
834
inv = tree1.inventory
837
expected_result1 = [('', '', root_id, 'd'),
838
('', 'a', 'a-id', 'd'),
839
('', 'a-b', 'a-b-id', 'd'),
840
('a', 'b', 'b-id', 'd'),
841
('a/b', 'foo', 'foo-id', 'f'),
842
('a-b', 'bar', 'bar-id', 'f'),
844
expected_result2 = [('', '', root_id, 'd'),
845
('', 'a', 'a-id', 'd'),
846
('', 'a-b', 'a-b-id', 'd'),
847
('a-b', 'bar', 'bar-id', 'f'),
849
state = dirstate.DirState.initialize('dirstate')
851
state.set_state_from_inventory(inv)
853
for entry in state._iter_entries():
854
values.append(entry[0] + entry[1][0][:1])
855
self.assertEqual(expected_result1, values)
857
state.set_state_from_inventory(inv)
859
for entry in state._iter_entries():
860
values.append(entry[0] + entry[1][0][:1])
861
self.assertEqual(expected_result2, values)
865
416
def test_set_path_id_no_parents(self):
866
417
"""The id of a path can be changed trivally with no parents."""
867
418
state = dirstate.DirState.initialize('dirstate')
869
420
# check precondition to be sure the state does change appropriately.
870
root_entry = (('', '', 'TREE_ROOT'), [('d', '', 0, False, 'x'*32)])
871
self.assertEqual([root_entry], list(state._iter_entries()))
872
self.assertEqual(root_entry, state._get_entry(0, path_utf8=''))
873
self.assertEqual(root_entry,
874
state._get_entry(0, fileid_utf8='TREE_ROOT'))
875
self.assertEqual((None, None),
876
state._get_entry(0, fileid_utf8='second-root-id'))
877
state.set_path_id('', 'second-root-id')
878
new_root_entry = (('', '', 'second-root-id'),
879
[('d', '', 0, False, 'x'*32)])
880
expected_rows = [new_root_entry]
422
[(('', '', 'TREE_ROOT'), [('d', '', 0, False,
423
'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])],
424
list(state._iter_entries()))
425
state.set_path_id('', 'foobarbaz')
427
(('', '', 'foobarbaz'), [('d', '', 0, False,
428
'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])]
881
429
self.assertEqual(expected_rows, list(state._iter_entries()))
882
self.assertEqual(new_root_entry, state._get_entry(0, path_utf8=''))
883
self.assertEqual(new_root_entry,
884
state._get_entry(0, fileid_utf8='second-root-id'))
885
self.assertEqual((None, None),
886
state._get_entry(0, fileid_utf8='TREE_ROOT'))
887
430
# should work across save too
891
434
state = dirstate.DirState.on_file('dirstate')
892
436
state.lock_read()
895
438
self.assertEqual(expected_rows, list(state._iter_entries()))
1506
class TestIterChildEntries(TestCaseWithDirState):
1508
def create_dirstate_with_two_trees(self):
1509
"""This dirstate contains multiple files and directories.
1519
b/h\xc3\xa5 h-\xc3\xa5-file #This is u'\xe5' encoded into utf-8
1521
Notice that a/e is an empty directory.
1523
There is one parent tree, which has the same shape with the following variations:
1524
b/g in the parent is gone.
1525
b/h in the parent has a different id
1526
b/i is new in the parent
1527
c is renamed to b/j in the parent
1529
:return: The dirstate, still write-locked.
1531
packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
1532
null_sha = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
1533
NULL_PARENT_DETAILS = dirstate.DirState.NULL_PARENT_DETAILS
1534
root_entry = ('', '', 'a-root-value'), [
1535
('d', '', 0, False, packed_stat),
1536
('d', '', 0, False, 'parent-revid'),
1538
a_entry = ('', 'a', 'a-dir'), [
1539
('d', '', 0, False, packed_stat),
1540
('d', '', 0, False, 'parent-revid'),
1542
b_entry = ('', 'b', 'b-dir'), [
1543
('d', '', 0, False, packed_stat),
1544
('d', '', 0, False, 'parent-revid'),
1546
c_entry = ('', 'c', 'c-file'), [
1547
('f', null_sha, 10, False, packed_stat),
1548
('r', 'b/j', 0, False, ''),
1550
d_entry = ('', 'd', 'd-file'), [
1551
('f', null_sha, 20, False, packed_stat),
1552
('f', 'd', 20, False, 'parent-revid'),
1554
e_entry = ('a', 'e', 'e-dir'), [
1555
('d', '', 0, False, packed_stat),
1556
('d', '', 0, False, 'parent-revid'),
1558
f_entry = ('a', 'f', 'f-file'), [
1559
('f', null_sha, 30, False, packed_stat),
1560
('f', 'f', 20, False, 'parent-revid'),
1562
g_entry = ('b', 'g', 'g-file'), [
1563
('f', null_sha, 30, False, packed_stat),
1564
NULL_PARENT_DETAILS,
1566
h_entry1 = ('b', 'h\xc3\xa5', 'h-\xc3\xa5-file1'), [
1567
('f', null_sha, 40, False, packed_stat),
1568
NULL_PARENT_DETAILS,
1570
h_entry2 = ('b', 'h\xc3\xa5', 'h-\xc3\xa5-file2'), [
1571
NULL_PARENT_DETAILS,
1572
('f', 'h', 20, False, 'parent-revid'),
1574
i_entry = ('b', 'i', 'i-file'), [
1575
NULL_PARENT_DETAILS,
1576
('f', 'h', 20, False, 'parent-revid'),
1578
j_entry = ('b', 'j', 'c-file'), [
1579
('r', 'c', 0, False, ''),
1580
('f', 'j', 20, False, 'parent-revid'),
1583
dirblocks.append(('', [root_entry]))
1584
dirblocks.append(('', [a_entry, b_entry, c_entry, d_entry]))
1585
dirblocks.append(('a', [e_entry, f_entry]))
1586
dirblocks.append(('b', [g_entry, h_entry1, h_entry2, i_entry, j_entry]))
1587
state = dirstate.DirState.initialize('dirstate')
1590
state._set_data(['parent'], dirblocks)
1594
return state, dirblocks
1596
def test_iter_children_b(self):
1597
state, dirblocks = self.create_dirstate_with_two_trees()
1598
self.addCleanup(state.unlock)
1599
expected_result = []
1600
expected_result.append(dirblocks[3][1][2]) # h2
1601
expected_result.append(dirblocks[3][1][3]) # i
1602
expected_result.append(dirblocks[3][1][4]) # j
1603
self.assertEqual(expected_result,
1604
list(state._iter_child_entries(1, 'b')))
1606
def test_iter_child_root(self):
1607
state, dirblocks = self.create_dirstate_with_two_trees()
1608
self.addCleanup(state.unlock)
1609
expected_result = []
1610
expected_result.append(dirblocks[1][1][0]) # a
1611
expected_result.append(dirblocks[1][1][1]) # b
1612
expected_result.append(dirblocks[1][1][3]) # d
1613
expected_result.append(dirblocks[2][1][0]) # e
1614
expected_result.append(dirblocks[2][1][1]) # f
1615
expected_result.append(dirblocks[3][1][2]) # h2
1616
expected_result.append(dirblocks[3][1][3]) # i
1617
expected_result.append(dirblocks[3][1][4]) # j
1618
self.assertEqual(expected_result,
1619
list(state._iter_child_entries(1, '')))
1622
class TestDirstateSortOrder(tests.TestCaseWithTransport):
1004
class TestDirstateSortOrder(TestCaseWithTransport):
1623
1005
"""Test that DirState adds entries in the right order."""
1625
1007
def test_add_sorting(self):
1735
1114
self.st_ino = ino
1736
1115
self.st_mode = mode
1740
return _FakeStat(st.st_size, st.st_mtime, st.st_ctime, st.st_dev,
1741
st.st_ino, st.st_mode)
1744
class TestPackStat(tests.TestCaseWithTransport):
1118
class TestUpdateEntry(TestCaseWithDirState):
1119
"""Test the DirState.update_entry functions"""
1121
def get_state_with_a(self):
1122
"""Create a DirState tracking a single object named 'a'"""
1123
state = InstrumentedDirState.initialize('dirstate')
1124
self.addCleanup(state.unlock)
1125
state.add('a', 'a-id', 'file', None, '')
1126
entry = state._get_entry(0, path_utf8='a')
1129
def test_update_entry(self):
1130
state, entry = self.get_state_with_a()
1131
self.build_tree(['a'])
1132
# Add one where we don't provide the stat or sha already
1133
self.assertEqual(('', 'a', 'a-id'), entry[0])
1134
self.assertEqual([('f', '', 0, False, dirstate.DirState.NULLSTAT)],
1136
# Flush the buffers to disk
1138
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1139
state._dirblock_state)
1141
stat_value = os.lstat('a')
1142
packed_stat = dirstate.pack_stat(stat_value)
1143
link_or_sha1 = state.update_entry(entry, abspath='a',
1144
stat_value=stat_value)
1145
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
1148
# The dirblock entry should be updated with the new info
1149
self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
1151
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1152
state._dirblock_state)
1153
mode = stat_value.st_mode
1154
self.assertEqual([('sha1', 'a'), ('is_exec', mode, False)], state._log)
1157
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1158
state._dirblock_state)
1160
# If we do it again right away, we don't know if the file has changed
1161
# so we will re-read the file. Roll the clock back so the file is
1162
# guaranteed to look too new.
1163
state.adjust_time(-10)
1165
link_or_sha1 = state.update_entry(entry, abspath='a',
1166
stat_value=stat_value)
1167
self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
1168
('sha1', 'a'), ('is_exec', mode, False),
1170
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
1172
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1173
state._dirblock_state)
1176
# However, if we move the clock forward so the file is considered
1177
# "stable", it should just returned the cached value.
1178
state.adjust_time(20)
1179
link_or_sha1 = state.update_entry(entry, abspath='a',
1180
stat_value=stat_value)
1181
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
1183
self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
1184
('sha1', 'a'), ('is_exec', mode, False),
1187
def test_update_entry_no_stat_value(self):
1188
"""Passing the stat_value is optional."""
1189
state, entry = self.get_state_with_a()
1190
state.adjust_time(-10) # Make sure the file looks new
1191
self.build_tree(['a'])
1192
# Add one where we don't provide the stat or sha already
1193
link_or_sha1 = state.update_entry(entry, abspath='a')
1194
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
1196
stat_value = os.lstat('a')
1197
self.assertEqual([('lstat', 'a'), ('sha1', 'a'),
1198
('is_exec', stat_value.st_mode, False),
1201
def test_update_entry_symlink(self):
1202
"""Update entry should read symlinks."""
1203
if not osutils.has_symlinks():
1204
return # PlatformDeficiency / TestSkipped
1205
state, entry = self.get_state_with_a()
1207
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1208
state._dirblock_state)
1209
os.symlink('target', 'a')
1211
state.adjust_time(-10) # Make the symlink look new
1212
stat_value = os.lstat('a')
1213
packed_stat = dirstate.pack_stat(stat_value)
1214
link_or_sha1 = state.update_entry(entry, abspath='a',
1215
stat_value=stat_value)
1216
self.assertEqual('target', link_or_sha1)
1217
self.assertEqual([('read_link', 'a', '')], state._log)
1218
# Dirblock is updated
1219
self.assertEqual([('l', link_or_sha1, 6, False, packed_stat)],
1221
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1222
state._dirblock_state)
1224
# Because the stat_value looks new, we should re-read the target
1225
link_or_sha1 = state.update_entry(entry, abspath='a',
1226
stat_value=stat_value)
1227
self.assertEqual('target', link_or_sha1)
1228
self.assertEqual([('read_link', 'a', ''),
1229
('read_link', 'a', 'target'),
1231
state.adjust_time(+20) # Skip into the future, all files look old
1232
link_or_sha1 = state.update_entry(entry, abspath='a',
1233
stat_value=stat_value)
1234
self.assertEqual('target', link_or_sha1)
1235
# There should not be a new read_link call.
1236
# (this is a weak assertion, because read_link is fairly inexpensive,
1237
# versus the number of symlinks that we would have)
1238
self.assertEqual([('read_link', 'a', ''),
1239
('read_link', 'a', 'target'),
1242
def test_update_entry_dir(self):
1243
state, entry = self.get_state_with_a()
1244
self.build_tree(['a/'])
1245
self.assertIs(None, state.update_entry(entry, 'a'))
1247
def create_and_test_file(self, state, entry):
1248
"""Create a file at 'a' and verify the state finds it.
1250
The state should already be versioning *something* at 'a'. This makes
1251
sure that state.update_entry recognizes it as a file.
1253
self.build_tree(['a'])
1254
stat_value = os.lstat('a')
1255
packed_stat = dirstate.pack_stat(stat_value)
1257
link_or_sha1 = state.update_entry(entry, abspath='a')
1258
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
1260
self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
1264
def create_and_test_dir(self, state, entry):
1265
"""Create a directory at 'a' and verify the state finds it.
1267
The state should already be versioning *something* at 'a'. This makes
1268
sure that state.update_entry recognizes it as a directory.
1270
self.build_tree(['a/'])
1271
stat_value = os.lstat('a')
1272
packed_stat = dirstate.pack_stat(stat_value)
1274
link_or_sha1 = state.update_entry(entry, abspath='a')
1275
self.assertIs(None, link_or_sha1)
1276
self.assertEqual([('d', '', 0, False, packed_stat)], entry[1])
1280
def create_and_test_symlink(self, state, entry):
1281
"""Create a symlink at 'a' and verify the state finds it.
1283
The state should already be versioning *something* at 'a'. This makes
1284
sure that state.update_entry recognizes it as a symlink.
1286
This should not be called if this platform does not have symlink
1289
os.symlink('path/to/foo', 'a')
1291
stat_value = os.lstat('a')
1292
packed_stat = dirstate.pack_stat(stat_value)
1294
link_or_sha1 = state.update_entry(entry, abspath='a')
1295
self.assertEqual('path/to/foo', link_or_sha1)
1296
self.assertEqual([('l', 'path/to/foo', 11, False, packed_stat)],
1300
def test_update_missing_file(self):
1301
state, entry = self.get_state_with_a()
1302
packed_stat = self.create_and_test_file(state, entry)
1303
# Now if we delete the file, update_entry should recover and
1306
self.assertIs(None, state.update_entry(entry, abspath='a'))
1307
# And the record shouldn't be changed.
1308
digest = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
1309
self.assertEqual([('f', digest, 14, False, packed_stat)],
1312
def test_update_missing_dir(self):
1313
state, entry = self.get_state_with_a()
1314
packed_stat = self.create_and_test_dir(state, entry)
1315
# Now if we delete the directory, update_entry should recover and
1318
self.assertIs(None, state.update_entry(entry, abspath='a'))
1319
self.assertEqual([('d', '', 0, False, packed_stat)], entry[1])
1321
def test_update_missing_symlink(self):
1322
if not osutils.has_symlinks():
1323
return # PlatformDeficiency / TestSkipped
1324
state, entry = self.get_state_with_a()
1325
packed_stat = self.create_and_test_symlink(state, entry)
1327
self.assertIs(None, state.update_entry(entry, abspath='a'))
1328
# And the record shouldn't be changed.
1329
self.assertEqual([('l', 'path/to/foo', 11, False, packed_stat)],
1332
def test_update_file_to_dir(self):
1333
"""If a file changes to a directory we return None for the sha.
1334
We also update the inventory record.
1336
state, entry = self.get_state_with_a()
1337
self.create_and_test_file(state, entry)
1339
self.create_and_test_dir(state, entry)
1341
def test_update_file_to_symlink(self):
1342
"""File becomes a symlink"""
1343
if not osutils.has_symlinks():
1344
return # PlatformDeficiency / TestSkipped
1345
state, entry = self.get_state_with_a()
1346
self.create_and_test_file(state, entry)
1348
self.create_and_test_symlink(state, entry)
1350
def test_update_dir_to_file(self):
1351
"""Directory becoming a file updates the entry."""
1352
state, entry = self.get_state_with_a()
1353
self.create_and_test_dir(state, entry)
1355
self.create_and_test_file(state, entry)
1357
def test_update_dir_to_symlink(self):
1358
"""Directory becomes a symlink"""
1359
if not osutils.has_symlinks():
1360
return # PlatformDeficiency / TestSkipped
1361
state, entry = self.get_state_with_a()
1362
self.create_and_test_dir(state, entry)
1364
self.create_and_test_symlink(state, entry)
1366
def test_update_symlink_to_file(self):
1367
"""Symlink becomes a file"""
1368
state, entry = self.get_state_with_a()
1369
self.create_and_test_symlink(state, entry)
1371
self.create_and_test_file(state, entry)
1373
def test_update_symlink_to_dir(self):
1374
"""Symlink becomes a directory"""
1375
state, entry = self.get_state_with_a()
1376
self.create_and_test_symlink(state, entry)
1378
self.create_and_test_dir(state, entry)
1380
def test__is_executable_win32(self):
1381
state, entry = self.get_state_with_a()
1382
self.build_tree(['a'])
1384
# Make sure we are using the win32 implementation of _is_executable
1385
state._is_executable = state._is_executable_win32
1387
# The file on disk is not executable, but we are marking it as though
1388
# it is. With _is_executable_win32 we ignore what is on disk.
1389
entry[1][0] = ('f', '', 0, True, dirstate.DirState.NULLSTAT)
1391
stat_value = os.lstat('a')
1392
packed_stat = dirstate.pack_stat(stat_value)
1394
state.adjust_time(-10) # Make sure everything is new
1395
# Make sure it wants to kkkkkkkk
1396
state.update_entry(entry, abspath='a', stat_value=stat_value)
1398
# The row is updated, but the executable bit stays set.
1399
digest = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
1400
self.assertEqual([('f', digest, 14, True, packed_stat)], entry[1])
1403
class TestPackStat(TestCaseWithTransport):
1746
1405
def assertPackStat(self, expected, stat_value):
1747
1406
"""Check the packed and serialized form of a stat value."""
1793
1452
self.assertPackStat('AAAbWEXm4FxF5uBmAAADCQBjLNIAAIGk', st)
1796
class TestBisect(TestCaseWithDirState):
1455
class TestBisect(TestCaseWithTransport):
1797
1456
"""Test the ability to bisect into the disk format."""
1458
def create_basic_dirstate(self):
1459
"""Create a dirstate with a few files and directories.
1468
tree = self.make_branch_and_tree('tree')
1469
paths = ['a', 'b/', 'b/c', 'b/d/', 'b/d/e', 'f']
1470
file_ids = ['a-id', 'b-id', 'c-id', 'd-id', 'e-id', 'f-id']
1471
self.build_tree(['tree/' + p for p in paths])
1472
tree.set_root_id('TREE_ROOT')
1473
tree.add([p.rstrip('/') for p in paths], file_ids)
1474
tree.commit('initial', rev_id='rev-1')
1475
revision_id = 'rev-1'
1476
# a_packed_stat = dirstate.pack_stat(os.stat('tree/a'))
1477
t = self.get_transport().clone('tree')
1478
a_text = t.get_bytes('a')
1479
a_sha = osutils.sha_string(a_text)
1481
# b_packed_stat = dirstate.pack_stat(os.stat('tree/b'))
1482
# c_packed_stat = dirstate.pack_stat(os.stat('tree/b/c'))
1483
c_text = t.get_bytes('b/c')
1484
c_sha = osutils.sha_string(c_text)
1486
# d_packed_stat = dirstate.pack_stat(os.stat('tree/b/d'))
1487
# e_packed_stat = dirstate.pack_stat(os.stat('tree/b/d/e'))
1488
e_text = t.get_bytes('b/d/e')
1489
e_sha = osutils.sha_string(e_text)
1491
# f_packed_stat = dirstate.pack_stat(os.stat('tree/f'))
1492
f_text = t.get_bytes('f')
1493
f_sha = osutils.sha_string(f_text)
1495
null_stat = dirstate.DirState.NULLSTAT
1497
'':(('', '', 'TREE_ROOT'), [
1498
('d', '', 0, False, null_stat),
1499
('d', '', 0, False, revision_id),
1501
'a':(('', 'a', 'a-id'), [
1502
('f', '', 0, False, null_stat),
1503
('f', a_sha, a_len, False, revision_id),
1505
'b':(('', 'b', 'b-id'), [
1506
('d', '', 0, False, null_stat),
1507
('d', '', 0, False, revision_id),
1509
'b/c':(('b', 'c', 'c-id'), [
1510
('f', '', 0, False, null_stat),
1511
('f', c_sha, c_len, False, revision_id),
1513
'b/d':(('b', 'd', 'd-id'), [
1514
('d', '', 0, False, null_stat),
1515
('d', '', 0, False, revision_id),
1517
'b/d/e':(('b/d', 'e', 'e-id'), [
1518
('f', '', 0, False, null_stat),
1519
('f', e_sha, e_len, False, revision_id),
1521
'f':(('', 'f', 'f-id'), [
1522
('f', '', 0, False, null_stat),
1523
('f', f_sha, f_len, False, revision_id),
1526
state = dirstate.DirState.from_tree(tree, 'dirstate')
1531
# Use a different object, to make sure nothing is pre-cached in memory.
1532
state = dirstate.DirState.on_file('dirstate')
1534
self.addCleanup(state.unlock)
1535
self.assertEqual(dirstate.DirState.NOT_IN_MEMORY,
1536
state._dirblock_state)
1537
# This is code is only really tested if we actually have to make more
1538
# than one read, so set the page size to something smaller.
1539
# We want it to contain about 2.2 records, so that we have a couple
1540
# records that we can read per attempt
1541
state._bisect_page_size = 200
1542
return tree, state, expected
1544
def create_duplicated_dirstate(self):
1545
"""Create a dirstate with a deleted and added entries.
1547
This grabs a basic_dirstate, and then removes and re adds every entry
1550
tree, state, expected = self.create_basic_dirstate()
1551
# Now we will just remove and add every file so we get an extra entry
1552
# per entry. Unversion in reverse order so we handle subdirs
1553
tree.unversion(['f-id', 'e-id', 'd-id', 'c-id', 'b-id', 'a-id'])
1554
tree.add(['a', 'b', 'b/c', 'b/d', 'b/d/e', 'f'],
1555
['a-id2', 'b-id2', 'c-id2', 'd-id2', 'e-id2', 'f-id2'])
1557
# Update the expected dictionary.
1558
for path in ['a', 'b', 'b/c', 'b/d', 'b/d/e', 'f']:
1559
orig = expected[path]
1561
# This record was deleted in the current tree
1562
expected[path] = (orig[0], [dirstate.DirState.NULL_PARENT_DETAILS,
1564
new_key = (orig[0][0], orig[0][1], orig[0][2]+'2')
1565
# And didn't exist in the basis tree
1566
expected[path2] = (new_key, [orig[1][0],
1567
dirstate.DirState.NULL_PARENT_DETAILS])
1569
# We will replace the 'dirstate' file underneath 'state', but that is
1570
# okay as lock as we unlock 'state' first.
1573
new_state = dirstate.DirState.from_tree(tree, 'dirstate')
1579
# But we need to leave state in a read-lock because we already have
1580
# a cleanup scheduled
1582
return tree, state, expected
1584
def create_renamed_dirstate(self):
1585
"""Create a dirstate with a few internal renames.
1587
This takes the basic dirstate, and moves the paths around.
1589
tree, state, expected = self.create_basic_dirstate()
1591
tree.rename_one('a', 'b/g')
1593
tree.rename_one('b/d', 'h')
1595
old_a = expected['a']
1596
expected['a'] = (old_a[0], [('r', 'b/g', 0, False, ''), old_a[1][1]])
1597
expected['b/g'] = (('b', 'g', 'a-id'), [old_a[1][0],
1598
('r', 'a', 0, False, '')])
1599
old_d = expected['b/d']
1600
expected['b/d'] = (old_d[0], [('r', 'h', 0, False, ''), old_d[1][1]])
1601
expected['h'] = (('', 'h', 'd-id'), [old_d[1][0],
1602
('r', 'b/d', 0, False, '')])
1604
old_e = expected['b/d/e']
1605
expected['b/d/e'] = (old_e[0], [('r', 'h/e', 0, False, ''),
1607
expected['h/e'] = (('h', 'e', 'e-id'), [old_e[1][0],
1608
('r', 'b/d/e', 0, False, '')])
1612
new_state = dirstate.DirState.from_tree(tree, 'dirstate')
1619
return tree, state, expected
1799
1621
def assertBisect(self, expected_map, map_keys, state, paths):
1800
1622
"""Assert that bisecting for paths returns the right result.
2035
class TestDirstateValidation(TestCaseWithDirState):
2037
def test_validate_correct_dirstate(self):
2038
state = self.create_complex_dirstate()
2041
# and make sure we can also validate with a read lock
2048
def test_dirblock_not_sorted(self):
2049
tree, state, expected = self.create_renamed_dirstate()
2050
state._read_dirblocks_if_needed()
2051
last_dirblock = state._dirblocks[-1]
2052
# we're appending to the dirblock, but this name comes before some of
2053
# the existing names; that's wrong
2054
last_dirblock[1].append(
2055
(('h', 'aaaa', 'a-id'),
2056
[('a', '', 0, False, ''),
2057
('a', '', 0, False, '')]))
2058
e = self.assertRaises(AssertionError,
2060
self.assertContainsRe(str(e), 'not sorted')
2062
def test_dirblock_name_mismatch(self):
2063
tree, state, expected = self.create_renamed_dirstate()
2064
state._read_dirblocks_if_needed()
2065
last_dirblock = state._dirblocks[-1]
2066
# add an entry with the wrong directory name
2067
last_dirblock[1].append(
2069
[('a', '', 0, False, ''),
2070
('a', '', 0, False, '')]))
2071
e = self.assertRaises(AssertionError,
2073
self.assertContainsRe(str(e),
2074
"doesn't match directory name")
2076
def test_dirblock_missing_rename(self):
2077
tree, state, expected = self.create_renamed_dirstate()
2078
state._read_dirblocks_if_needed()
2079
last_dirblock = state._dirblocks[-1]
2080
# make another entry for a-id, without a correct 'r' pointer to
2081
# the real occurrence in the working tree
2082
last_dirblock[1].append(
2083
(('h', 'z', 'a-id'),
2084
[('a', '', 0, False, ''),
2085
('a', '', 0, False, '')]))
2086
e = self.assertRaises(AssertionError,
2088
self.assertContainsRe(str(e),
2089
'file a-id is absent in row')
2092
class TestDirstateTreeReference(TestCaseWithDirState):
2094
def test_reference_revision_is_none(self):
2095
tree = self.make_branch_and_tree('tree', format='dirstate-with-subtree')
2096
subtree = self.make_branch_and_tree('tree/subtree',
2097
format='dirstate-with-subtree')
2098
subtree.set_root_id('subtree')
2099
tree.add_reference(subtree)
2101
state = dirstate.DirState.from_tree(tree, 'dirstate')
2102
key = ('', 'subtree', 'subtree')
2103
expected = ('', [(key,
2104
[('t', '', 0, False, 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])])
2107
self.assertEqual(expected, state._find_block(key))
2112
class TestDiscardMergeParents(TestCaseWithDirState):
2114
def test_discard_no_parents(self):
2115
# This should be a no-op
2116
state = self.create_empty_dirstate()
2117
self.addCleanup(state.unlock)
2118
state._discard_merge_parents()
2121
def test_discard_one_parent(self):
2123
packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
2124
root_entry_direntry = ('', '', 'a-root-value'), [
2125
('d', '', 0, False, packed_stat),
2126
('d', '', 0, False, packed_stat),
2129
dirblocks.append(('', [root_entry_direntry]))
2130
dirblocks.append(('', []))
2132
state = self.create_empty_dirstate()
2133
self.addCleanup(state.unlock)
2134
state._set_data(['parent-id'], dirblocks[:])
2137
state._discard_merge_parents()
2139
self.assertEqual(dirblocks, state._dirblocks)
2141
def test_discard_simple(self):
2143
packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
2144
root_entry_direntry = ('', '', 'a-root-value'), [
2145
('d', '', 0, False, packed_stat),
2146
('d', '', 0, False, packed_stat),
2147
('d', '', 0, False, packed_stat),
2149
expected_root_entry_direntry = ('', '', 'a-root-value'), [
2150
('d', '', 0, False, packed_stat),
2151
('d', '', 0, False, packed_stat),
2154
dirblocks.append(('', [root_entry_direntry]))
2155
dirblocks.append(('', []))
2157
state = self.create_empty_dirstate()
2158
self.addCleanup(state.unlock)
2159
state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2162
# This should strip of the extra column
2163
state._discard_merge_parents()
2165
expected_dirblocks = [('', [expected_root_entry_direntry]), ('', [])]
2166
self.assertEqual(expected_dirblocks, state._dirblocks)
2168
def test_discard_absent(self):
2169
"""If entries are only in a merge, discard should remove the entries"""
2170
null_stat = dirstate.DirState.NULLSTAT
2171
present_dir = ('d', '', 0, False, null_stat)
2172
present_file = ('f', '', 0, False, null_stat)
2173
absent = dirstate.DirState.NULL_PARENT_DETAILS
2174
root_key = ('', '', 'a-root-value')
2175
file_in_root_key = ('', 'file-in-root', 'a-file-id')
2176
file_in_merged_key = ('', 'file-in-merged', 'b-file-id')
2177
dirblocks = [('', [(root_key, [present_dir, present_dir, present_dir])]),
2178
('', [(file_in_merged_key,
2179
[absent, absent, present_file]),
2181
[present_file, present_file, present_file]),
2185
state = self.create_empty_dirstate()
2186
self.addCleanup(state.unlock)
2187
state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2190
exp_dirblocks = [('', [(root_key, [present_dir, present_dir])]),
2191
('', [(file_in_root_key,
2192
[present_file, present_file]),
2195
state._discard_merge_parents()
2197
self.assertEqual(exp_dirblocks, state._dirblocks)
2199
def test_discard_renamed(self):
2200
null_stat = dirstate.DirState.NULLSTAT
2201
present_dir = ('d', '', 0, False, null_stat)
2202
present_file = ('f', '', 0, False, null_stat)
2203
absent = dirstate.DirState.NULL_PARENT_DETAILS
2204
root_key = ('', '', 'a-root-value')
2205
file_in_root_key = ('', 'file-in-root', 'a-file-id')
2206
# Renamed relative to parent
2207
file_rename_s_key = ('', 'file-s', 'b-file-id')
2208
file_rename_t_key = ('', 'file-t', 'b-file-id')
2209
# And one that is renamed between the parents, but absent in this
2210
key_in_1 = ('', 'file-in-1', 'c-file-id')
2211
key_in_2 = ('', 'file-in-2', 'c-file-id')
2214
('', [(root_key, [present_dir, present_dir, present_dir])]),
2216
[absent, present_file, ('r', 'file-in-2', 'c-file-id')]),
2218
[absent, ('r', 'file-in-1', 'c-file-id'), present_file]),
2220
[present_file, present_file, present_file]),
2222
[('r', 'file-t', 'b-file-id'), absent, present_file]),
2224
[present_file, absent, ('r', 'file-s', 'b-file-id')]),
2228
('', [(root_key, [present_dir, present_dir])]),
2229
('', [(key_in_1, [absent, present_file]),
2230
(file_in_root_key, [present_file, present_file]),
2231
(file_rename_t_key, [present_file, absent]),
2234
state = self.create_empty_dirstate()
2235
self.addCleanup(state.unlock)
2236
state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2239
state._discard_merge_parents()
2241
self.assertEqual(exp_dirblocks, state._dirblocks)
2243
def test_discard_all_subdir(self):
2244
null_stat = dirstate.DirState.NULLSTAT
2245
present_dir = ('d', '', 0, False, null_stat)
2246
present_file = ('f', '', 0, False, null_stat)
2247
absent = dirstate.DirState.NULL_PARENT_DETAILS
2248
root_key = ('', '', 'a-root-value')
2249
subdir_key = ('', 'sub', 'dir-id')
2250
child1_key = ('sub', 'child1', 'child1-id')
2251
child2_key = ('sub', 'child2', 'child2-id')
2252
child3_key = ('sub', 'child3', 'child3-id')
2255
('', [(root_key, [present_dir, present_dir, present_dir])]),
2256
('', [(subdir_key, [present_dir, present_dir, present_dir])]),
2257
('sub', [(child1_key, [absent, absent, present_file]),
2258
(child2_key, [absent, absent, present_file]),
2259
(child3_key, [absent, absent, present_file]),
2263
('', [(root_key, [present_dir, present_dir])]),
2264
('', [(subdir_key, [present_dir, present_dir])]),
2267
state = self.create_empty_dirstate()
2268
self.addCleanup(state.unlock)
2269
state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2272
state._discard_merge_parents()
2274
self.assertEqual(exp_dirblocks, state._dirblocks)
2277
class Test_InvEntryToDetails(tests.TestCase):
2279
def assertDetails(self, expected, inv_entry):
2280
details = dirstate.DirState._inv_entry_to_details(inv_entry)
2281
self.assertEqual(expected, details)
2282
# details should always allow join() and always be a plain str when
2284
(minikind, fingerprint, size, executable, tree_data) = details
2285
self.assertIsInstance(minikind, str)
2286
self.assertIsInstance(fingerprint, str)
2287
self.assertIsInstance(tree_data, str)
2289
def test_unicode_symlink(self):
2290
inv_entry = inventory.InventoryLink('link-file-id',
2291
u'nam\N{Euro Sign}e',
2293
inv_entry.revision = 'link-revision-id'
2294
target = u'link-targ\N{Euro Sign}t'
2295
inv_entry.symlink_target = target
2296
self.assertDetails(('l', target.encode('UTF-8'), 0, False,
2297
'link-revision-id'), inv_entry)
2300
class TestSHA1Provider(tests.TestCaseInTempDir):
2302
def test_sha1provider_is_an_interface(self):
2303
p = dirstate.SHA1Provider()
2304
self.assertRaises(NotImplementedError, p.sha1, "foo")
2305
self.assertRaises(NotImplementedError, p.stat_and_sha1, "foo")
2307
def test_defaultsha1provider_sha1(self):
2308
text = 'test\r\nwith\nall\rpossible line endings\r\n'
2309
self.build_tree_contents([('foo', text)])
2310
expected_sha = osutils.sha_string(text)
2311
p = dirstate.DefaultSHA1Provider()
2312
self.assertEqual(expected_sha, p.sha1('foo'))
2314
def test_defaultsha1provider_stat_and_sha1(self):
2315
text = 'test\r\nwith\nall\rpossible line endings\r\n'
2316
self.build_tree_contents([('foo', text)])
2317
expected_sha = osutils.sha_string(text)
2318
p = dirstate.DefaultSHA1Provider()
2319
statvalue, sha1 = p.stat_and_sha1('foo')
2320
self.assertTrue(len(statvalue) >= 10)
2321
self.assertEqual(len(text), statvalue.st_size)
2322
self.assertEqual(expected_sha, sha1)
1849
class TestBisectDirblock(TestCase):
1850
"""Test that bisect_dirblock() returns the expected values.
1852
bisect_dirblock is intended to work like bisect.bisect_left() except it
1853
knows it is working on dirblocks and that dirblocks are sorted by ('path',
1854
'to', 'foo') chunks rather than by raw 'path/to/foo'.
1857
def assertBisect(self, dirblocks, split_dirblocks, path, *args, **kwargs):
1858
"""Assert that bisect_split works like bisect_left on the split paths.
1860
:param dirblocks: A list of (path, [info]) pairs.
1861
:param split_dirblocks: A list of ((split, path), [info]) pairs.
1862
:param path: The path we are indexing.
1864
All other arguments will be passed along.
1866
bisect_split_idx = dirstate.bisect_dirblock(dirblocks, path,
1868
split_dirblock = (path.split('/'), [])
1869
bisect_left_idx = bisect.bisect_left(split_dirblocks, split_dirblock,
1871
self.assertEqual(bisect_left_idx, bisect_split_idx,
1872
'bisect_split disagreed. %s != %s'
1874
% (bisect_left_idx, bisect_split_idx, path)
1877
def paths_to_dirblocks(self, paths):
1878
"""Convert a list of paths into dirblock form.
1880
Also, ensure that the paths are in proper sorted order.
1882
dirblocks = [(path, []) for path in paths]
1883
split_dirblocks = [(path.split('/'), []) for path in paths]
1884
self.assertEqual(sorted(split_dirblocks), split_dirblocks)
1885
return dirblocks, split_dirblocks
1887
def test_simple(self):
1888
"""In the simple case it works just like bisect_left"""
1889
paths = ['', 'a', 'b', 'c', 'd']
1890
dirblocks, split_dirblocks = self.paths_to_dirblocks(paths)
1892
self.assertBisect(dirblocks, split_dirblocks, path)
1893
self.assertBisect(dirblocks, split_dirblocks, '_')
1894
self.assertBisect(dirblocks, split_dirblocks, 'aa')
1895
self.assertBisect(dirblocks, split_dirblocks, 'bb')
1896
self.assertBisect(dirblocks, split_dirblocks, 'cc')
1897
self.assertBisect(dirblocks, split_dirblocks, 'dd')
1898
self.assertBisect(dirblocks, split_dirblocks, 'a/a')
1899
self.assertBisect(dirblocks, split_dirblocks, 'b/b')
1900
self.assertBisect(dirblocks, split_dirblocks, 'c/c')
1901
self.assertBisect(dirblocks, split_dirblocks, 'd/d')
1903
def test_involved(self):
1904
"""This is where bisect_left diverges slightly."""
1906
'a/a', 'a/a/a', 'a/a/z', 'a/a-a', 'a/a-z',
1907
'a/z', 'a/z/a', 'a/z/z', 'a/z-a', 'a/z-z',
1909
'z', 'z/a/a', 'z/a/z', 'z/a-a', 'z/a-z',
1910
'z/z', 'z/z/a', 'z/z/z', 'z/z-a', 'z/z-z',
1913
dirblocks, split_dirblocks = self.paths_to_dirblocks(paths)
1915
self.assertBisect(dirblocks, split_dirblocks, path)
1917
def test_involved_cached(self):
1918
"""This is where bisect_left diverges slightly."""
1920
'a/a', 'a/a/a', 'a/a/z', 'a/a-a', 'a/a-z',
1921
'a/z', 'a/z/a', 'a/z/z', 'a/z-a', 'a/z-z',
1923
'z', 'z/a/a', 'z/a/z', 'z/a-a', 'z/a-z',
1924
'z/z', 'z/z/a', 'z/z/z', 'z/z-a', 'z/z-z',
1928
dirblocks, split_dirblocks = self.paths_to_dirblocks(paths)
1930
self.assertBisect(dirblocks, split_dirblocks, path, cache=cache)
added
removed
bzrlib/tests/test_dirstate.py
