195
194
tree = self.make_branch_and_tree('tree')
196
paths = ['a', 'b/', 'b/c', 'b/d/', 'b/d/e', 'b-c', 'f']
197
file_ids = ['a-id', 'b-id', 'c-id', 'd-id', 'e-id', 'b-c-id', 'f-id']
195
paths = ['a', 'b/', 'b/c', 'b/d/', 'b/d/e', 'f']
196
file_ids = ['a-id', 'b-id', 'c-id', 'd-id', 'e-id', 'f-id']
198
197
self.build_tree(['tree/' + p for p in paths])
199
198
tree.set_root_id('TREE_ROOT')
200
199
tree.add([p.rstrip('/') for p in paths], file_ids)
201
200
tree.commit('initial', rev_id='rev-1')
202
201
revision_id = 'rev-1'
203
202
# a_packed_stat = dirstate.pack_stat(os.stat('tree/a'))
204
t = self.get_transport('tree')
203
t = self.get_transport().clone('tree')
205
204
a_text = t.get_bytes('a')
206
205
a_sha = osutils.sha_string(a_text)
207
206
a_len = len(a_text)
248
244
('f', '', 0, False, null_stat),
249
245
('f', e_sha, e_len, False, revision_id),
251
'b-c':(('', 'b-c', 'b-c-id'), [
252
('f', '', 0, False, null_stat),
253
('f', b_c_sha, b_c_len, False, revision_id),
255
247
'f':(('', 'f', 'f-id'), [
256
248
('f', '', 0, False, null_stat),
257
249
('f', f_sha, f_len, False, revision_id),
284
276
tree, state, expected = self.create_basic_dirstate()
285
277
# Now we will just remove and add every file so we get an extra entry
286
278
# per entry. Unversion in reverse order so we handle subdirs
287
tree.unversion(['f-id', 'b-c-id', 'e-id', 'd-id', 'c-id', 'b-id', 'a-id'])
288
tree.add(['a', 'b', 'b/c', 'b/d', 'b/d/e', 'b-c', 'f'],
289
['a-id2', 'b-id2', 'c-id2', 'd-id2', 'e-id2', 'b-c-id2', 'f-id2'])
279
tree.unversion(['f-id', 'e-id', 'd-id', 'c-id', 'b-id', 'a-id'])
280
tree.add(['a', 'b', 'b/c', 'b/d', 'b/d/e', 'f'],
281
['a-id2', 'b-id2', 'c-id2', 'd-id2', 'e-id2', 'f-id2'])
291
283
# Update the expected dictionary.
292
for path in ['a', 'b', 'b/c', 'b/d', 'b/d/e', 'b-c', 'f']:
284
for path in ['a', 'b', 'b/c', 'b/d', 'b/d/e', 'f']:
293
285
orig = expected[path]
294
286
path2 = path + '2'
295
287
# This record was deleted in the current tree
700
688
# This will unlock it
701
689
self.check_state_with_reopen(expected_result, state)
703
def test_set_state_from_inventory_mixed_paths(self):
704
tree1 = self.make_branch_and_tree('tree1')
705
self.build_tree(['tree1/a/', 'tree1/a/b/', 'tree1/a-b/',
706
'tree1/a/b/foo', 'tree1/a-b/bar'])
709
tree1.add(['a', 'a/b', 'a-b', 'a/b/foo', 'a-b/bar'],
710
['a-id', 'b-id', 'a-b-id', 'foo-id', 'bar-id'])
711
tree1.commit('rev1', rev_id='rev1')
712
root_id = tree1.get_root_id()
713
inv = tree1.inventory
716
expected_result1 = [('', '', root_id, 'd'),
717
('', 'a', 'a-id', 'd'),
718
('', 'a-b', 'a-b-id', 'd'),
719
('a', 'b', 'b-id', 'd'),
720
('a/b', 'foo', 'foo-id', 'f'),
721
('a-b', 'bar', 'bar-id', 'f'),
723
expected_result2 = [('', '', root_id, 'd'),
724
('', 'a', 'a-id', 'd'),
725
('', 'a-b', 'a-b-id', 'd'),
726
('a-b', 'bar', 'bar-id', 'f'),
728
state = dirstate.DirState.initialize('dirstate')
730
state.set_state_from_inventory(inv)
732
for entry in state._iter_entries():
733
values.append(entry[0] + entry[1][0][:1])
734
self.assertEqual(expected_result1, values)
736
state.set_state_from_inventory(inv)
738
for entry in state._iter_entries():
739
values.append(entry[0] + entry[1][0][:1])
740
self.assertEqual(expected_result2, values)
744
691
def test_set_path_id_no_parents(self):
745
692
"""The id of a path can be changed trivally with no parents."""
746
693
state = dirstate.DirState.initialize('dirstate')
1501
1448
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1502
1449
state._dirblock_state)
1503
self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
1507
1452
# However, if we move the clock forward so the file is considered
1508
# "stable", it should just cache the value.
1509
state.adjust_time(+20)
1453
# "stable", it should just returned the cached value.
1454
state.adjust_time(20)
1510
1455
link_or_sha1 = state.update_entry(entry, abspath='a',
1511
1456
stat_value=stat_value)
1512
1457
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
1514
1459
self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
1515
1460
('sha1', 'a'), ('is_exec', mode, False),
1516
('sha1', 'a'), ('is_exec', mode, False),
1518
self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
1521
# Subsequent calls will just return the cached value
1522
link_or_sha1 = state.update_entry(entry, abspath='a',
1523
stat_value=stat_value)
1463
def test_update_entry_no_stat_value(self):
1464
"""Passing the stat_value is optional."""
1465
state, entry = self.get_state_with_a()
1466
state.adjust_time(-10) # Make sure the file looks new
1467
self.build_tree(['a'])
1468
# Add one where we don't provide the stat or sha already
1469
link_or_sha1 = state.update_entry(entry, abspath='a')
1524
1470
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
1526
self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
1527
('sha1', 'a'), ('is_exec', mode, False),
1528
('sha1', 'a'), ('is_exec', mode, False),
1472
stat_value = os.lstat('a')
1473
self.assertEqual([('lstat', 'a'), ('sha1', 'a'),
1474
('is_exec', stat_value.st_mode, False),
1530
self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
1533
1477
def test_update_entry_symlink(self):
1534
1478
"""Update entry should read symlinks."""
1559
1503
stat_value=stat_value)
1560
1504
self.assertEqual('target', link_or_sha1)
1561
1505
self.assertEqual([('read_link', 'a', ''),
1562
('read_link', 'a', ''),
1506
('read_link', 'a', 'target'),
1564
self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
1566
1508
state.adjust_time(+20) # Skip into the future, all files look old
1567
1509
link_or_sha1 = state.update_entry(entry, abspath='a',
1568
1510
stat_value=stat_value)
1569
1511
self.assertEqual('target', link_or_sha1)
1570
# We need to re-read the link because only now can we cache it
1571
self.assertEqual([('read_link', 'a', ''),
1572
('read_link', 'a', ''),
1573
('read_link', 'a', ''),
1575
self.assertEqual([('l', 'target', 6, False, packed_stat)],
1578
# Another call won't re-read the link
1579
self.assertEqual([('read_link', 'a', ''),
1580
('read_link', 'a', ''),
1581
('read_link', 'a', ''),
1583
link_or_sha1 = state.update_entry(entry, abspath='a',
1584
stat_value=stat_value)
1585
self.assertEqual('target', link_or_sha1)
1586
self.assertEqual([('l', 'target', 6, False, packed_stat)],
1589
def do_update_entry(self, state, entry, abspath):
1590
stat_value = os.lstat(abspath)
1591
return state.update_entry(entry, abspath, stat_value)
1512
# There should not be a new read_link call.
1513
# (this is a weak assertion, because read_link is fairly inexpensive,
1514
# versus the number of symlinks that we would have)
1515
self.assertEqual([('read_link', 'a', ''),
1516
('read_link', 'a', 'target'),
1593
1519
def test_update_entry_dir(self):
1594
1520
state, entry = self.get_state_with_a()
1595
1521
self.build_tree(['a/'])
1596
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1598
def test_update_entry_dir_unchanged(self):
1599
state, entry = self.get_state_with_a()
1600
self.build_tree(['a/'])
1601
state.adjust_time(+20)
1602
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1603
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1604
state._dirblock_state)
1606
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1607
state._dirblock_state)
1608
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1609
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1610
state._dirblock_state)
1612
def test_update_entry_file_unchanged(self):
1613
state, entry = self.get_state_with_a()
1614
self.build_tree(['a'])
1615
sha1sum = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
1616
state.adjust_time(+20)
1617
self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
1618
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1619
state._dirblock_state)
1621
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1622
state._dirblock_state)
1623
self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
1624
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1625
state._dirblock_state)
1522
self.assertIs(None, state.update_entry(entry, 'a'))
1627
1524
def create_and_test_file(self, state, entry):
1628
1525
"""Create a file at 'a' and verify the state finds it.
1672
1569
stat_value = os.lstat('a')
1673
1570
packed_stat = dirstate.pack_stat(stat_value)
1675
link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
1572
link_or_sha1 = state.update_entry(entry, abspath='a')
1676
1573
self.assertEqual('path/to/foo', link_or_sha1)
1677
1574
self.assertEqual([('l', 'path/to/foo', 11, False, packed_stat)],
1679
1576
return packed_stat
1578
def test_update_missing_file(self):
1579
state, entry = self.get_state_with_a()
1580
packed_stat = self.create_and_test_file(state, entry)
1581
# Now if we delete the file, update_entry should recover and
1584
self.assertIs(None, state.update_entry(entry, abspath='a'))
1585
# And the record shouldn't be changed.
1586
digest = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
1587
self.assertEqual([('f', digest, 14, False, packed_stat)],
1590
def test_update_missing_dir(self):
1591
state, entry = self.get_state_with_a()
1592
packed_stat = self.create_and_test_dir(state, entry)
1593
# Now if we delete the directory, update_entry should recover and
1596
self.assertIs(None, state.update_entry(entry, abspath='a'))
1597
self.assertEqual([('d', '', 0, False, packed_stat)], entry[1])
1599
def test_update_missing_symlink(self):
1600
if not osutils.has_symlinks():
1601
# PlatformDeficiency / TestSkipped
1602
raise TestSkipped("No symlink support")
1603
state, entry = self.get_state_with_a()
1604
packed_stat = self.create_and_test_symlink(state, entry)
1606
self.assertIs(None, state.update_entry(entry, abspath='a'))
1607
# And the record shouldn't be changed.
1608
self.assertEqual([('l', 'path/to/foo', 11, False, packed_stat)],
1681
1611
def test_update_file_to_dir(self):
1682
1612
"""If a file changes to a directory we return None for the sha.
1683
1613
We also update the inventory record.
1685
1615
state, entry = self.get_state_with_a()
1686
# The file sha1 won't be cached unless the file is old
1687
state.adjust_time(+10)
1688
1616
self.create_and_test_file(state, entry)
1690
1618
self.create_and_test_dir(state, entry)
1759
1677
packed_stat = dirstate.pack_stat(stat_value)
1761
1679
state.adjust_time(-10) # Make sure everything is new
1680
# Make sure it wants to kkkkkkkk
1762
1681
state.update_entry(entry, abspath='a', stat_value=stat_value)
1764
1683
# The row is updated, but the executable bit stays set.
1765
self.assertEqual([('f', '', 14, True, dirstate.DirState.NULLSTAT)],
1768
# Make the disk object look old enough to cache
1769
state.adjust_time(+20)
1770
1684
digest = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
1771
state.update_entry(entry, abspath='a', stat_value=stat_value)
1772
1685
self.assertEqual([('f', digest, 14, True, packed_stat)], entry[1])
1837
1751
(dir, name) tuples, and sorted according to how _bisect
1840
result = state._bisect(paths)
1754
dir_names = sorted(osutils.split(p) for p in paths)
1755
result = state._bisect(dir_names)
1841
1756
# For now, results are just returned in whatever order we read them.
1842
1757
# We could sort by (dir, name, file_id) or something like that, but in
1843
1758
# the end it would still be fairly arbitrary, and we don't want the
1844
1759
# extra overhead if we can avoid it. So sort everything to make sure
1845
1760
# equality is true
1846
assert len(map_keys) == len(paths)
1761
assert len(map_keys) == len(dir_names)
1848
for path, keys in zip(paths, map_keys):
1763
for dir_name, keys in zip(dir_names, map_keys):
1849
1764
if keys is None:
1850
1765
# This should not be present in the output
1852
expected[path] = sorted(expected_map[k] for k in keys)
1767
expected[dir_name] = sorted(expected_map[k] for k in keys)
1854
# The returned values are just arranged randomly based on when they
1855
# were read, for testing, make sure it is properly sorted.
1769
for dir_name in result:
1770
result[dir_name].sort()
1859
1772
self.assertEqual(expected, result)
1921
1834
# Bisect should be capable of finding multiple entries at the same time
1922
1835
self.assertBisect(expected, [['a'], ['b'], ['f']],
1923
1836
state, ['a', 'b', 'f'])
1837
# ('', 'f') sorts before the others
1924
1838
self.assertBisect(expected, [['f'], ['b/d'], ['b/d/e']],
1925
state, ['f', 'b/d', 'b/d/e'])
1926
self.assertBisect(expected, [['b'], ['b-c'], ['b/c']],
1927
state, ['b', 'b-c', 'b/c'])
1839
state, ['b/d', 'b/d/e', 'f'])
1929
1841
def test_bisect_one_page(self):
1930
1842
"""Test bisect when there is only 1 page to read"""
1936
1848
self.assertBisect(expected,[['b/c']], state, ['b/c'])
1937
1849
self.assertBisect(expected,[['b/d']], state, ['b/d'])
1938
1850
self.assertBisect(expected,[['b/d/e']], state, ['b/d/e'])
1939
self.assertBisect(expected,[['b-c']], state, ['b-c'])
1940
1851
self.assertBisect(expected,[['f']], state, ['f'])
1941
1852
self.assertBisect(expected,[['a'], ['b'], ['f']],
1942
1853
state, ['a', 'b', 'f'])
1943
self.assertBisect(expected, [['b/d'], ['b/d/e'], ['f']],
1854
# ('', 'f') sorts before the others
1855
self.assertBisect(expected, [['f'], ['b/d'], ['b/d/e']],
1944
1856
state, ['b/d', 'b/d/e', 'f'])
1945
self.assertBisect(expected, [['b'], ['b/c'], ['b-c']],
1946
state, ['b', 'b/c', 'b-c'])
1948
1858
def test_bisect_duplicate_paths(self):
1949
1859
"""When bisecting for a path, handle multiple entries."""
2001
1908
def test_bisect_dirblocks(self):
2002
1909
tree, state, expected = self.create_duplicated_dirstate()
2003
1910
self.assertBisectDirBlocks(expected,
2004
[['', 'a', 'a2', 'b', 'b2', 'b-c', 'b-c2', 'f', 'f2']],
1911
[['', 'a', 'a2', 'b', 'b2', 'f', 'f2']], state, [''])
2006
1912
self.assertBisectDirBlocks(expected,
2007
1913
[['b/c', 'b/c2', 'b/d', 'b/d2']], state, ['b'])
2008
1914
self.assertBisectDirBlocks(expected,
2009
1915
[['b/d/e', 'b/d/e2']], state, ['b/d'])
2010
1916
self.assertBisectDirBlocks(expected,
2011
[['', 'a', 'a2', 'b', 'b2', 'b-c', 'b-c2', 'f', 'f2'],
1917
[['', 'a', 'a2', 'b', 'b2', 'f', 'f2'],
2012
1918
['b/c', 'b/c2', 'b/d', 'b/d2'],
2013
1919
['b/d/e', 'b/d/e2'],
2014
1920
], state, ['', 'b', 'b/d'])
2029
1935
self.assertBisectRecursive(expected, ['a'], state, ['a'])
2030
1936
self.assertBisectRecursive(expected, ['b/c'], state, ['b/c'])
2031
1937
self.assertBisectRecursive(expected, ['b/d/e'], state, ['b/d/e'])
2032
self.assertBisectRecursive(expected, ['b-c'], state, ['b-c'])
2033
1938
self.assertBisectRecursive(expected, ['b/d', 'b/d/e'],
2034
1939
state, ['b/d'])
2035
1940
self.assertBisectRecursive(expected, ['b', 'b/c', 'b/d', 'b/d/e'],
2037
self.assertBisectRecursive(expected, ['', 'a', 'b', 'b-c', 'f', 'b/c',
1942
self.assertBisectRecursive(expected, ['', 'a', 'b', 'f', 'b/c',
2038
1943
'b/d', 'b/d/e'],
1972
class TestBisectDirblock(TestCase):
1973
"""Test that bisect_dirblock() returns the expected values.
1975
bisect_dirblock is intended to work like bisect.bisect_left() except it
1976
knows it is working on dirblocks and that dirblocks are sorted by ('path',
1977
'to', 'foo') chunks rather than by raw 'path/to/foo'.
1980
def assertBisect(self, dirblocks, split_dirblocks, path, *args, **kwargs):
1981
"""Assert that bisect_split works like bisect_left on the split paths.
1983
:param dirblocks: A list of (path, [info]) pairs.
1984
:param split_dirblocks: A list of ((split, path), [info]) pairs.
1985
:param path: The path we are indexing.
1987
All other arguments will be passed along.
1989
bisect_split_idx = dirstate.bisect_dirblock(dirblocks, path,
1991
split_dirblock = (path.split('/'), [])
1992
bisect_left_idx = bisect.bisect_left(split_dirblocks, split_dirblock,
1994
self.assertEqual(bisect_left_idx, bisect_split_idx,
1995
'bisect_split disagreed. %s != %s'
1997
% (bisect_left_idx, bisect_split_idx, path)
2000
def paths_to_dirblocks(self, paths):
2001
"""Convert a list of paths into dirblock form.
2003
Also, ensure that the paths are in proper sorted order.
2005
dirblocks = [(path, []) for path in paths]
2006
split_dirblocks = [(path.split('/'), []) for path in paths]
2007
self.assertEqual(sorted(split_dirblocks), split_dirblocks)
2008
return dirblocks, split_dirblocks
2010
def test_simple(self):
2011
"""In the simple case it works just like bisect_left"""
2012
paths = ['', 'a', 'b', 'c', 'd']
2013
dirblocks, split_dirblocks = self.paths_to_dirblocks(paths)
2015
self.assertBisect(dirblocks, split_dirblocks, path)
2016
self.assertBisect(dirblocks, split_dirblocks, '_')
2017
self.assertBisect(dirblocks, split_dirblocks, 'aa')
2018
self.assertBisect(dirblocks, split_dirblocks, 'bb')
2019
self.assertBisect(dirblocks, split_dirblocks, 'cc')
2020
self.assertBisect(dirblocks, split_dirblocks, 'dd')
2021
self.assertBisect(dirblocks, split_dirblocks, 'a/a')
2022
self.assertBisect(dirblocks, split_dirblocks, 'b/b')
2023
self.assertBisect(dirblocks, split_dirblocks, 'c/c')
2024
self.assertBisect(dirblocks, split_dirblocks, 'd/d')
2026
def test_involved(self):
2027
"""This is where bisect_left diverges slightly."""
2029
'a/a', 'a/a/a', 'a/a/z', 'a/a-a', 'a/a-z',
2030
'a/z', 'a/z/a', 'a/z/z', 'a/z-a', 'a/z-z',
2032
'z', 'z/a/a', 'z/a/z', 'z/a-a', 'z/a-z',
2033
'z/z', 'z/z/a', 'z/z/z', 'z/z-a', 'z/z-z',
2036
dirblocks, split_dirblocks = self.paths_to_dirblocks(paths)
2038
self.assertBisect(dirblocks, split_dirblocks, path)
2040
def test_involved_cached(self):
2041
"""This is where bisect_left diverges slightly."""
2043
'a/a', 'a/a/a', 'a/a/z', 'a/a-a', 'a/a-z',
2044
'a/z', 'a/z/a', 'a/z/z', 'a/z-a', 'a/z-z',
2046
'z', 'z/a/a', 'z/a/z', 'z/a-a', 'z/a-z',
2047
'z/z', 'z/z/a', 'z/z/z', 'z/z-a', 'z/z-z',
2051
dirblocks, split_dirblocks = self.paths_to_dirblocks(paths)
2053
self.assertBisect(dirblocks, split_dirblocks, path, cache=cache)
2067
2056
class TestDirstateValidation(TestCaseWithDirState):
2069
2058
def test_validate_correct_dirstate(self):
added
removed
bzrlib/tests/test_dirstate.py
