688
738
# This will unlock it
689
739
self.check_state_with_reopen(expected_result, state)
741
def test_set_state_from_inventory_preserves_hashcache(self):
742
# https://bugs.launchpad.net/bzr/+bug/146176
743
# set_state_from_inventory should preserve the stat and hash value for
744
# workingtree files that are not changed by the inventory.
746
tree = self.make_branch_and_tree('.')
747
# depends on the default format using dirstate...
750
# make a dirstate with some valid hashcache data
751
# file on disk, but that's not needed for this test
752
foo_contents = 'contents of foo'
753
self.build_tree_contents([('foo', foo_contents)])
754
tree.add('foo', 'foo-id')
756
foo_stat = os.stat('foo')
757
foo_packed = dirstate.pack_stat(foo_stat)
758
foo_sha = osutils.sha_string(foo_contents)
759
foo_size = len(foo_contents)
761
# should not be cached yet, because the file's too fresh
763
(('', 'foo', 'foo-id',),
764
[('f', '', 0, False, dirstate.DirState.NULLSTAT)]),
765
tree._dirstate._get_entry(0, 'foo-id'))
766
# poke in some hashcache information - it wouldn't normally be
767
# stored because it's too fresh
768
tree._dirstate.update_minimal(
769
('', 'foo', 'foo-id'),
770
'f', False, foo_sha, foo_packed, foo_size, 'foo')
771
# now should be cached
773
(('', 'foo', 'foo-id',),
774
[('f', foo_sha, foo_size, False, foo_packed)]),
775
tree._dirstate._get_entry(0, 'foo-id'))
777
# extract the inventory, and add something to it
778
inv = tree._get_inventory()
779
# should see the file we poked in...
780
self.assertTrue(inv.has_id('foo-id'))
781
self.assertTrue(inv.has_filename('foo'))
782
inv.add_path('bar', 'file', 'bar-id')
783
tree._dirstate._validate()
784
# this used to cause it to lose its hashcache
785
tree._dirstate.set_state_from_inventory(inv)
786
tree._dirstate._validate()
792
# now check that the state still has the original hashcache value
793
state = tree._dirstate
795
foo_tuple = state._get_entry(0, path_utf8='foo')
797
(('', 'foo', 'foo-id',),
798
[('f', foo_sha, len(foo_contents), False,
799
dirstate.pack_stat(foo_stat))]),
805
def test_set_state_from_inventory_mixed_paths(self):
806
tree1 = self.make_branch_and_tree('tree1')
807
self.build_tree(['tree1/a/', 'tree1/a/b/', 'tree1/a-b/',
808
'tree1/a/b/foo', 'tree1/a-b/bar'])
811
tree1.add(['a', 'a/b', 'a-b', 'a/b/foo', 'a-b/bar'],
812
['a-id', 'b-id', 'a-b-id', 'foo-id', 'bar-id'])
813
tree1.commit('rev1', rev_id='rev1')
814
root_id = tree1.get_root_id()
815
inv = tree1.inventory
818
expected_result1 = [('', '', root_id, 'd'),
819
('', 'a', 'a-id', 'd'),
820
('', 'a-b', 'a-b-id', 'd'),
821
('a', 'b', 'b-id', 'd'),
822
('a/b', 'foo', 'foo-id', 'f'),
823
('a-b', 'bar', 'bar-id', 'f'),
825
expected_result2 = [('', '', root_id, 'd'),
826
('', 'a', 'a-id', 'd'),
827
('', 'a-b', 'a-b-id', 'd'),
828
('a-b', 'bar', 'bar-id', 'f'),
830
state = dirstate.DirState.initialize('dirstate')
832
state.set_state_from_inventory(inv)
834
for entry in state._iter_entries():
835
values.append(entry[0] + entry[1][0][:1])
836
self.assertEqual(expected_result1, values)
838
state.set_state_from_inventory(inv)
840
for entry in state._iter_entries():
841
values.append(entry[0] + entry[1][0][:1])
842
self.assertEqual(expected_result2, values)
691
846
def test_set_path_id_no_parents(self):
692
847
"""The id of a path can be changed trivally with no parents."""
693
848
state = dirstate.DirState.initialize('dirstate')
1434
class TestIterChildEntries(TestCaseWithDirState):
1436
def create_dirstate_with_two_trees(self):
1437
"""This dirstate contains multiple files and directories.
1447
b/h\xc3\xa5 h-\xc3\xa5-file #This is u'\xe5' encoded into utf-8
1449
Notice that a/e is an empty directory.
1451
There is one parent tree, which has the same shape with the following variations:
1452
b/g in the parent is gone.
1453
b/h in the parent has a different id
1454
b/i is new in the parent
1455
c is renamed to b/j in the parent
1457
:return: The dirstate, still write-locked.
1459
packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
1460
null_sha = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
1461
NULL_PARENT_DETAILS = dirstate.DirState.NULL_PARENT_DETAILS
1462
root_entry = ('', '', 'a-root-value'), [
1463
('d', '', 0, False, packed_stat),
1464
('d', '', 0, False, 'parent-revid'),
1466
a_entry = ('', 'a', 'a-dir'), [
1467
('d', '', 0, False, packed_stat),
1468
('d', '', 0, False, 'parent-revid'),
1470
b_entry = ('', 'b', 'b-dir'), [
1471
('d', '', 0, False, packed_stat),
1472
('d', '', 0, False, 'parent-revid'),
1474
c_entry = ('', 'c', 'c-file'), [
1475
('f', null_sha, 10, False, packed_stat),
1476
('r', 'b/j', 0, False, ''),
1478
d_entry = ('', 'd', 'd-file'), [
1479
('f', null_sha, 20, False, packed_stat),
1480
('f', 'd', 20, False, 'parent-revid'),
1482
e_entry = ('a', 'e', 'e-dir'), [
1483
('d', '', 0, False, packed_stat),
1484
('d', '', 0, False, 'parent-revid'),
1486
f_entry = ('a', 'f', 'f-file'), [
1487
('f', null_sha, 30, False, packed_stat),
1488
('f', 'f', 20, False, 'parent-revid'),
1490
g_entry = ('b', 'g', 'g-file'), [
1491
('f', null_sha, 30, False, packed_stat),
1492
NULL_PARENT_DETAILS,
1494
h_entry1 = ('b', 'h\xc3\xa5', 'h-\xc3\xa5-file1'), [
1495
('f', null_sha, 40, False, packed_stat),
1496
NULL_PARENT_DETAILS,
1498
h_entry2 = ('b', 'h\xc3\xa5', 'h-\xc3\xa5-file2'), [
1499
NULL_PARENT_DETAILS,
1500
('f', 'h', 20, False, 'parent-revid'),
1502
i_entry = ('b', 'i', 'i-file'), [
1503
NULL_PARENT_DETAILS,
1504
('f', 'h', 20, False, 'parent-revid'),
1506
j_entry = ('b', 'j', 'c-file'), [
1507
('r', 'c', 0, False, ''),
1508
('f', 'j', 20, False, 'parent-revid'),
1511
dirblocks.append(('', [root_entry]))
1512
dirblocks.append(('', [a_entry, b_entry, c_entry, d_entry]))
1513
dirblocks.append(('a', [e_entry, f_entry]))
1514
dirblocks.append(('b', [g_entry, h_entry1, h_entry2, i_entry, j_entry]))
1515
state = dirstate.DirState.initialize('dirstate')
1518
state._set_data(['parent'], dirblocks)
1522
return state, dirblocks
1524
def test_iter_children_b(self):
1525
state, dirblocks = self.create_dirstate_with_two_trees()
1526
self.addCleanup(state.unlock)
1527
expected_result = []
1528
expected_result.append(dirblocks[3][1][2]) # h2
1529
expected_result.append(dirblocks[3][1][3]) # i
1530
expected_result.append(dirblocks[3][1][4]) # j
1531
self.assertEqual(expected_result,
1532
list(state._iter_child_entries(1, 'b')))
1534
def test_iter_child_root(self):
1535
state, dirblocks = self.create_dirstate_with_two_trees()
1536
self.addCleanup(state.unlock)
1537
expected_result = []
1538
expected_result.append(dirblocks[1][1][0]) # a
1539
expected_result.append(dirblocks[1][1][1]) # b
1540
expected_result.append(dirblocks[1][1][3]) # d
1541
expected_result.append(dirblocks[2][1][0]) # e
1542
expected_result.append(dirblocks[2][1][1]) # f
1543
expected_result.append(dirblocks[3][1][2]) # h2
1544
expected_result.append(dirblocks[3][1][3]) # i
1545
expected_result.append(dirblocks[3][1][4]) # j
1546
self.assertEqual(expected_result,
1547
list(state._iter_child_entries(1, '')))
1280
1550
class TestDirstateSortOrder(TestCaseWithTransport):
1281
1551
"""Test that DirState adds entries in the right order."""
1448
1720
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1449
1721
state._dirblock_state)
1722
self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
1452
1726
# However, if we move the clock forward so the file is considered
1453
# "stable", it should just returned the cached value.
1454
state.adjust_time(20)
1727
# "stable", it should just cache the value.
1728
state.adjust_time(+20)
1455
1729
link_or_sha1 = state.update_entry(entry, abspath='a',
1456
1730
stat_value=stat_value)
1457
1731
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
1459
1733
self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
1460
1734
('sha1', 'a'), ('is_exec', mode, False),
1735
('sha1', 'a'), ('is_exec', mode, False),
1737
self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
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')
1740
# Subsequent calls will just return the cached value
1741
link_or_sha1 = state.update_entry(entry, abspath='a',
1742
stat_value=stat_value)
1470
1743
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
1472
stat_value = os.lstat('a')
1473
self.assertEqual([('lstat', 'a'), ('sha1', 'a'),
1474
('is_exec', stat_value.st_mode, False),
1745
self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
1746
('sha1', 'a'), ('is_exec', mode, False),
1747
('sha1', 'a'), ('is_exec', mode, False),
1749
self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
1477
1752
def test_update_entry_symlink(self):
1478
1753
"""Update entry should read symlinks."""
1479
if not osutils.has_symlinks():
1480
# PlatformDeficiency / TestSkipped
1481
raise TestSkipped("No symlink support")
1754
self.requireFeature(SymlinkFeature)
1482
1755
state, entry = self.get_state_with_a()
1484
1757
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1503
1776
stat_value=stat_value)
1504
1777
self.assertEqual('target', link_or_sha1)
1505
1778
self.assertEqual([('read_link', 'a', ''),
1506
('read_link', 'a', 'target'),
1779
('read_link', 'a', ''),
1781
self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
1508
1783
state.adjust_time(+20) # Skip into the future, all files look old
1509
1784
link_or_sha1 = state.update_entry(entry, abspath='a',
1510
1785
stat_value=stat_value)
1511
1786
self.assertEqual('target', link_or_sha1)
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'),
1787
# We need to re-read the link because only now can we cache it
1788
self.assertEqual([('read_link', 'a', ''),
1789
('read_link', 'a', ''),
1790
('read_link', 'a', ''),
1792
self.assertEqual([('l', 'target', 6, False, packed_stat)],
1795
# Another call won't re-read the link
1796
self.assertEqual([('read_link', 'a', ''),
1797
('read_link', 'a', ''),
1798
('read_link', 'a', ''),
1800
link_or_sha1 = state.update_entry(entry, abspath='a',
1801
stat_value=stat_value)
1802
self.assertEqual('target', link_or_sha1)
1803
self.assertEqual([('l', 'target', 6, False, packed_stat)],
1806
def do_update_entry(self, state, entry, abspath):
1807
stat_value = os.lstat(abspath)
1808
return state.update_entry(entry, abspath, stat_value)
1519
1810
def test_update_entry_dir(self):
1520
1811
state, entry = self.get_state_with_a()
1521
1812
self.build_tree(['a/'])
1522
self.assertIs(None, state.update_entry(entry, 'a'))
1813
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1815
def test_update_entry_dir_unchanged(self):
1816
state, entry = self.get_state_with_a()
1817
self.build_tree(['a/'])
1818
state.adjust_time(+20)
1819
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1820
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1821
state._dirblock_state)
1823
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1824
state._dirblock_state)
1825
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1826
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1827
state._dirblock_state)
1829
def test_update_entry_file_unchanged(self):
1830
state, entry = self.get_state_with_a()
1831
self.build_tree(['a'])
1832
sha1sum = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
1833
state.adjust_time(+20)
1834
self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
1835
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1836
state._dirblock_state)
1838
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1839
state._dirblock_state)
1840
self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
1841
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1842
state._dirblock_state)
1524
1844
def create_and_test_file(self, state, entry):
1525
1845
"""Create a file at 'a' and verify the state finds it.
1569
1889
stat_value = os.lstat('a')
1570
1890
packed_stat = dirstate.pack_stat(stat_value)
1572
link_or_sha1 = state.update_entry(entry, abspath='a')
1892
link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
1573
1893
self.assertEqual('path/to/foo', link_or_sha1)
1574
1894
self.assertEqual([('l', 'path/to/foo', 11, False, packed_stat)],
1576
1896
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)],
1611
1898
def test_update_file_to_dir(self):
1612
1899
"""If a file changes to a directory we return None for the sha.
1613
1900
We also update the inventory record.
1615
1902
state, entry = self.get_state_with_a()
1903
# The file sha1 won't be cached unless the file is old
1904
state.adjust_time(+10)
1616
1905
self.create_and_test_file(state, entry)
1618
1907
self.create_and_test_dir(state, entry)
1620
1909
def test_update_file_to_symlink(self):
1621
1910
"""File becomes a symlink"""
1622
if not osutils.has_symlinks():
1623
# PlatformDeficiency / TestSkipped
1624
raise TestSkipped("No symlink support")
1911
self.requireFeature(SymlinkFeature)
1625
1912
state, entry = self.get_state_with_a()
1913
# The file sha1 won't be cached unless the file is old
1914
state.adjust_time(+10)
1626
1915
self.create_and_test_file(state, entry)
1628
1917
self.create_and_test_symlink(state, entry)
1971
class TestBisectDirblock(TestCase):
1972
"""Test that bisect_dirblock() returns the expected values.
1974
bisect_dirblock is intended to work like bisect.bisect_left() except it
1975
knows it is working on dirblocks and that dirblocks are sorted by ('path',
1976
'to', 'foo') chunks rather than by raw 'path/to/foo'.
1980
super(TestBisectDirblock, self).setUp()
1981
# We have to set this here, because if we set it at the class variable
1982
# level, Python interprets it as a member function, and passes 'self'
1983
# as the first argument.
1984
self.bisect_dirblock_func = dirstate.py_bisect_dirblock
1986
def assertBisect(self, dirblocks, split_dirblocks, path, *args, **kwargs):
1987
"""Assert that bisect_split works like bisect_left on the split paths.
1989
:param dirblocks: A list of (path, [info]) pairs.
1990
:param split_dirblocks: A list of ((split, path), [info]) pairs.
1991
:param path: The path we are indexing.
1993
All other arguments will be passed along.
1995
self.assertIsInstance(dirblocks, list)
1996
bisect_split_idx = self.bisect_dirblock_func(dirblocks, path,
1998
split_dirblock = (path.split('/'), [])
1999
bisect_left_idx = bisect.bisect_left(split_dirblocks, split_dirblock,
2001
self.assertEqual(bisect_left_idx, bisect_split_idx,
2002
'bisect_split disagreed. %s != %s'
2004
% (bisect_left_idx, bisect_split_idx, path)
2007
def paths_to_dirblocks(self, paths):
2008
"""Convert a list of paths into dirblock form.
2010
Also, ensure that the paths are in proper sorted order.
2012
dirblocks = [(path, []) for path in paths]
2013
split_dirblocks = [(path.split('/'), []) for path in paths]
2014
self.assertEqual(sorted(split_dirblocks), split_dirblocks)
2015
return dirblocks, split_dirblocks
2017
def test_simple(self):
2018
"""In the simple case it works just like bisect_left"""
2019
paths = ['', 'a', 'b', 'c', 'd']
2020
dirblocks, split_dirblocks = self.paths_to_dirblocks(paths)
2022
self.assertBisect(dirblocks, split_dirblocks, path)
2023
self.assertBisect(dirblocks, split_dirblocks, '_')
2024
self.assertBisect(dirblocks, split_dirblocks, 'aa')
2025
self.assertBisect(dirblocks, split_dirblocks, 'bb')
2026
self.assertBisect(dirblocks, split_dirblocks, 'cc')
2027
self.assertBisect(dirblocks, split_dirblocks, 'dd')
2028
self.assertBisect(dirblocks, split_dirblocks, 'a/a')
2029
self.assertBisect(dirblocks, split_dirblocks, 'b/b')
2030
self.assertBisect(dirblocks, split_dirblocks, 'c/c')
2031
self.assertBisect(dirblocks, split_dirblocks, 'd/d')
2033
def test_involved(self):
2034
"""This is where bisect_left diverges slightly."""
2036
'a/a', 'a/a/a', 'a/a/z', 'a/a-a', 'a/a-z',
2037
'a/z', 'a/z/a', 'a/z/z', 'a/z-a', 'a/z-z',
2039
'z', 'z/a/a', 'z/a/z', 'z/a-a', 'z/a-z',
2040
'z/z', 'z/z/a', 'z/z/z', 'z/z-a', 'z/z-z',
2043
dirblocks, split_dirblocks = self.paths_to_dirblocks(paths)
2045
self.assertBisect(dirblocks, split_dirblocks, path)
2047
def test_involved_cached(self):
2048
"""This is where bisect_left diverges slightly."""
2050
'a/a', 'a/a/a', 'a/a/z', 'a/a-a', 'a/a-z',
2051
'a/z', 'a/z/a', 'a/z/z', 'a/z-a', 'a/z-z',
2053
'z', 'z/a/a', 'z/a/z', 'z/a-a', 'z/a-z',
2054
'z/z', 'z/z/a', 'z/z/z', 'z/z-a', 'z/z-z',
2058
dirblocks, split_dirblocks = self.paths_to_dirblocks(paths)
2060
self.assertBisect(dirblocks, split_dirblocks, path, cache=cache)
2063
2278
class TestDirstateValidation(TestCaseWithDirState):
2065
2280
def test_validate_correct_dirstate(self):
2115
2330
state._validate)
2116
2331
self.assertContainsRe(str(e),
2117
2332
'file a-id is absent in row')
2335
class TestDirstateTreeReference(TestCaseWithDirState):
2337
def test_reference_revision_is_none(self):
2338
tree = self.make_branch_and_tree('tree', format='dirstate-with-subtree')
2339
subtree = self.make_branch_and_tree('tree/subtree',
2340
format='dirstate-with-subtree')
2341
subtree.set_root_id('subtree')
2342
tree.add_reference(subtree)
2344
state = dirstate.DirState.from_tree(tree, 'dirstate')
2345
key = ('', 'subtree', 'subtree')
2346
expected = ('', [(key,
2347
[('t', '', 0, False, 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])])
2350
self.assertEqual(expected, state._find_block(key))
2355
class TestDiscardMergeParents(TestCaseWithDirState):
2357
def test_discard_no_parents(self):
2358
# This should be a no-op
2359
state = self.create_empty_dirstate()
2360
self.addCleanup(state.unlock)
2361
state._discard_merge_parents()
2364
def test_discard_one_parent(self):
2366
packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
2367
root_entry_direntry = ('', '', 'a-root-value'), [
2368
('d', '', 0, False, packed_stat),
2369
('d', '', 0, False, packed_stat),
2372
dirblocks.append(('', [root_entry_direntry]))
2373
dirblocks.append(('', []))
2375
state = self.create_empty_dirstate()
2376
self.addCleanup(state.unlock)
2377
state._set_data(['parent-id'], dirblocks[:])
2380
state._discard_merge_parents()
2382
self.assertEqual(dirblocks, state._dirblocks)
2384
def test_discard_simple(self):
2386
packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
2387
root_entry_direntry = ('', '', 'a-root-value'), [
2388
('d', '', 0, False, packed_stat),
2389
('d', '', 0, False, packed_stat),
2390
('d', '', 0, False, packed_stat),
2392
expected_root_entry_direntry = ('', '', 'a-root-value'), [
2393
('d', '', 0, False, packed_stat),
2394
('d', '', 0, False, packed_stat),
2397
dirblocks.append(('', [root_entry_direntry]))
2398
dirblocks.append(('', []))
2400
state = self.create_empty_dirstate()
2401
self.addCleanup(state.unlock)
2402
state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2405
# This should strip of the extra column
2406
state._discard_merge_parents()
2408
expected_dirblocks = [('', [expected_root_entry_direntry]), ('', [])]
2409
self.assertEqual(expected_dirblocks, state._dirblocks)
2411
def test_discard_absent(self):
2412
"""If entries are only in a merge, discard should remove the entries"""
2413
null_stat = dirstate.DirState.NULLSTAT
2414
present_dir = ('d', '', 0, False, null_stat)
2415
present_file = ('f', '', 0, False, null_stat)
2416
absent = dirstate.DirState.NULL_PARENT_DETAILS
2417
root_key = ('', '', 'a-root-value')
2418
file_in_root_key = ('', 'file-in-root', 'a-file-id')
2419
file_in_merged_key = ('', 'file-in-merged', 'b-file-id')
2420
dirblocks = [('', [(root_key, [present_dir, present_dir, present_dir])]),
2421
('', [(file_in_merged_key,
2422
[absent, absent, present_file]),
2424
[present_file, present_file, present_file]),
2428
state = self.create_empty_dirstate()
2429
self.addCleanup(state.unlock)
2430
state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2433
exp_dirblocks = [('', [(root_key, [present_dir, present_dir])]),
2434
('', [(file_in_root_key,
2435
[present_file, present_file]),
2438
state._discard_merge_parents()
2440
self.assertEqual(exp_dirblocks, state._dirblocks)
2442
def test_discard_renamed(self):
2443
null_stat = dirstate.DirState.NULLSTAT
2444
present_dir = ('d', '', 0, False, null_stat)
2445
present_file = ('f', '', 0, False, null_stat)
2446
absent = dirstate.DirState.NULL_PARENT_DETAILS
2447
root_key = ('', '', 'a-root-value')
2448
file_in_root_key = ('', 'file-in-root', 'a-file-id')
2449
# Renamed relative to parent
2450
file_rename_s_key = ('', 'file-s', 'b-file-id')
2451
file_rename_t_key = ('', 'file-t', 'b-file-id')
2452
# And one that is renamed between the parents, but absent in this
2453
key_in_1 = ('', 'file-in-1', 'c-file-id')
2454
key_in_2 = ('', 'file-in-2', 'c-file-id')
2457
('', [(root_key, [present_dir, present_dir, present_dir])]),
2459
[absent, present_file, ('r', 'file-in-2', 'c-file-id')]),
2461
[absent, ('r', 'file-in-1', 'c-file-id'), present_file]),
2463
[present_file, present_file, present_file]),
2465
[('r', 'file-t', 'b-file-id'), absent, present_file]),
2467
[present_file, absent, ('r', 'file-s', 'b-file-id')]),
2471
('', [(root_key, [present_dir, present_dir])]),
2472
('', [(key_in_1, [absent, present_file]),
2473
(file_in_root_key, [present_file, present_file]),
2474
(file_rename_t_key, [present_file, absent]),
2477
state = self.create_empty_dirstate()
2478
self.addCleanup(state.unlock)
2479
state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2482
state._discard_merge_parents()
2484
self.assertEqual(exp_dirblocks, state._dirblocks)
2486
def test_discard_all_subdir(self):
2487
null_stat = dirstate.DirState.NULLSTAT
2488
present_dir = ('d', '', 0, False, null_stat)
2489
present_file = ('f', '', 0, False, null_stat)
2490
absent = dirstate.DirState.NULL_PARENT_DETAILS
2491
root_key = ('', '', 'a-root-value')
2492
subdir_key = ('', 'sub', 'dir-id')
2493
child1_key = ('sub', 'child1', 'child1-id')
2494
child2_key = ('sub', 'child2', 'child2-id')
2495
child3_key = ('sub', 'child3', 'child3-id')
2498
('', [(root_key, [present_dir, present_dir, present_dir])]),
2499
('', [(subdir_key, [present_dir, present_dir, present_dir])]),
2500
('sub', [(child1_key, [absent, absent, present_file]),
2501
(child2_key, [absent, absent, present_file]),
2502
(child3_key, [absent, absent, present_file]),
2506
('', [(root_key, [present_dir, present_dir])]),
2507
('', [(subdir_key, [present_dir, present_dir])]),
2510
state = self.create_empty_dirstate()
2511
self.addCleanup(state.unlock)
2512
state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2515
state._discard_merge_parents()
2517
self.assertEqual(exp_dirblocks, state._dirblocks)
added
removed
bzrlib/tests/test_dirstate.py
