907
769
state._validate()
909
771
state.set_parent_trees([('parent-revid', rt)], ghosts=[])
910
root_entry = (('', '', 'TREE_ROOT'),
911
[('d', '', 0, False, 'x'*32),
912
('d', '', 0, False, 'parent-revid')])
913
self.assertEqual(root_entry, state._get_entry(0, path_utf8=''))
914
self.assertEqual(root_entry,
915
state._get_entry(0, fileid_utf8='TREE_ROOT'))
916
self.assertEqual((None, None),
917
state._get_entry(0, fileid_utf8='Asecond-root-id'))
918
state.set_path_id('', 'Asecond-root-id')
772
state.set_path_id('', 'foobarbaz')
919
773
state._validate()
920
774
# now see that it is what we expected
921
old_root_entry = (('', '', 'TREE_ROOT'),
922
[('a', '', 0, False, ''),
923
('d', '', 0, False, 'parent-revid')])
924
new_root_entry = (('', '', 'Asecond-root-id'),
925
[('d', '', 0, False, ''),
926
('a', '', 0, False, '')])
927
expected_rows = [new_root_entry, old_root_entry]
776
(('', '', 'TREE_ROOT'),
777
[('a', '', 0, False, ''),
778
('d', '', 0, False, 'parent-revid'),
780
(('', '', 'foobarbaz'),
781
[('d', '', 0, False, ''),
782
('a', '', 0, False, ''),
928
785
state._validate()
929
786
self.assertEqual(expected_rows, list(state._iter_entries()))
930
self.assertEqual(new_root_entry, state._get_entry(0, path_utf8=''))
931
self.assertEqual(old_root_entry, state._get_entry(1, path_utf8=''))
932
self.assertEqual((None, None),
933
state._get_entry(0, fileid_utf8='TREE_ROOT'))
934
self.assertEqual(old_root_entry,
935
state._get_entry(1, fileid_utf8='TREE_ROOT'))
936
self.assertEqual(new_root_entry,
937
state._get_entry(0, fileid_utf8='Asecond-root-id'))
938
self.assertEqual((None, None),
939
state._get_entry(1, fileid_utf8='Asecond-root-id'))
940
787
# should work across save too
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):
1324
class TestDirstateSortOrder(TestCaseWithTransport):
1623
1325
"""Test that DirState adds entries in the right order."""
1625
1327
def test_add_sorting(self):
1735
1434
self.st_ino = ino
1736
1435
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):
1438
class TestUpdateEntry(TestCaseWithDirState):
1439
"""Test the DirState.update_entry functions"""
1441
def get_state_with_a(self):
1442
"""Create a DirState tracking a single object named 'a'"""
1443
state = InstrumentedDirState.initialize('dirstate')
1444
self.addCleanup(state.unlock)
1445
state.add('a', 'a-id', 'file', None, '')
1446
entry = state._get_entry(0, path_utf8='a')
1449
def test_update_entry(self):
1450
state, entry = self.get_state_with_a()
1451
self.build_tree(['a'])
1452
# Add one where we don't provide the stat or sha already
1453
self.assertEqual(('', 'a', 'a-id'), entry[0])
1454
self.assertEqual([('f', '', 0, False, dirstate.DirState.NULLSTAT)],
1456
# Flush the buffers to disk
1458
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1459
state._dirblock_state)
1461
stat_value = os.lstat('a')
1462
packed_stat = dirstate.pack_stat(stat_value)
1463
link_or_sha1 = state.update_entry(entry, abspath='a',
1464
stat_value=stat_value)
1465
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
1468
# The dirblock entry should not cache the file's sha1
1469
self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
1471
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1472
state._dirblock_state)
1473
mode = stat_value.st_mode
1474
self.assertEqual([('sha1', 'a'), ('is_exec', mode, False)], state._log)
1477
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1478
state._dirblock_state)
1480
# If we do it again right away, we don't know if the file has changed
1481
# so we will re-read the file. Roll the clock back so the file is
1482
# guaranteed to look too new.
1483
state.adjust_time(-10)
1485
link_or_sha1 = state.update_entry(entry, abspath='a',
1486
stat_value=stat_value)
1487
self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
1488
('sha1', 'a'), ('is_exec', mode, False),
1490
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
1492
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1493
state._dirblock_state)
1494
self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
1498
# However, if we move the clock forward so the file is considered
1499
# "stable", it should just cache the value.
1500
state.adjust_time(+20)
1501
link_or_sha1 = state.update_entry(entry, abspath='a',
1502
stat_value=stat_value)
1503
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
1505
self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
1506
('sha1', 'a'), ('is_exec', mode, False),
1507
('sha1', 'a'), ('is_exec', mode, False),
1509
self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
1512
# Subsequent calls will just return the cached value
1513
link_or_sha1 = state.update_entry(entry, abspath='a',
1514
stat_value=stat_value)
1515
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
1517
self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
1518
('sha1', 'a'), ('is_exec', mode, False),
1519
('sha1', 'a'), ('is_exec', mode, False),
1521
self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
1524
def test_update_entry_symlink(self):
1525
"""Update entry should read symlinks."""
1526
if not osutils.has_symlinks():
1527
# PlatformDeficiency / TestSkipped
1528
raise TestSkipped("No symlink support")
1529
state, entry = self.get_state_with_a()
1531
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1532
state._dirblock_state)
1533
os.symlink('target', 'a')
1535
state.adjust_time(-10) # Make the symlink look new
1536
stat_value = os.lstat('a')
1537
packed_stat = dirstate.pack_stat(stat_value)
1538
link_or_sha1 = state.update_entry(entry, abspath='a',
1539
stat_value=stat_value)
1540
self.assertEqual('target', link_or_sha1)
1541
self.assertEqual([('read_link', 'a', '')], state._log)
1542
# Dirblock is not updated (the link is too new)
1543
self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
1545
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1546
state._dirblock_state)
1548
# Because the stat_value looks new, we should re-read the target
1549
link_or_sha1 = state.update_entry(entry, abspath='a',
1550
stat_value=stat_value)
1551
self.assertEqual('target', link_or_sha1)
1552
self.assertEqual([('read_link', 'a', ''),
1553
('read_link', 'a', ''),
1555
self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
1557
state.adjust_time(+20) # Skip into the future, all files look old
1558
link_or_sha1 = state.update_entry(entry, abspath='a',
1559
stat_value=stat_value)
1560
self.assertEqual('target', link_or_sha1)
1561
# We need to re-read the link because only now can we cache it
1562
self.assertEqual([('read_link', 'a', ''),
1563
('read_link', 'a', ''),
1564
('read_link', 'a', ''),
1566
self.assertEqual([('l', 'target', 6, False, packed_stat)],
1569
# Another call won't re-read the link
1570
self.assertEqual([('read_link', 'a', ''),
1571
('read_link', 'a', ''),
1572
('read_link', 'a', ''),
1574
link_or_sha1 = state.update_entry(entry, abspath='a',
1575
stat_value=stat_value)
1576
self.assertEqual('target', link_or_sha1)
1577
self.assertEqual([('l', 'target', 6, False, packed_stat)],
1580
def do_update_entry(self, state, entry, abspath):
1581
stat_value = os.lstat(abspath)
1582
return state.update_entry(entry, abspath, stat_value)
1584
def test_update_entry_dir(self):
1585
state, entry = self.get_state_with_a()
1586
self.build_tree(['a/'])
1587
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1589
def test_update_entry_dir_unchanged(self):
1590
state, entry = self.get_state_with_a()
1591
self.build_tree(['a/'])
1592
state.adjust_time(+20)
1593
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1594
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1595
state._dirblock_state)
1597
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1598
state._dirblock_state)
1599
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1600
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1601
state._dirblock_state)
1603
def test_update_entry_file_unchanged(self):
1604
state, entry = self.get_state_with_a()
1605
self.build_tree(['a'])
1606
sha1sum = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
1607
state.adjust_time(+20)
1608
self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
1609
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1610
state._dirblock_state)
1612
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1613
state._dirblock_state)
1614
self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
1615
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1616
state._dirblock_state)
1618
def create_and_test_file(self, state, entry):
1619
"""Create a file at 'a' and verify the state finds it.
1621
The state should already be versioning *something* at 'a'. This makes
1622
sure that state.update_entry recognizes it as a file.
1624
self.build_tree(['a'])
1625
stat_value = os.lstat('a')
1626
packed_stat = dirstate.pack_stat(stat_value)
1628
link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
1629
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
1631
self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
1635
def create_and_test_dir(self, state, entry):
1636
"""Create a directory at 'a' and verify the state finds it.
1638
The state should already be versioning *something* at 'a'. This makes
1639
sure that state.update_entry recognizes it as a directory.
1641
self.build_tree(['a/'])
1642
stat_value = os.lstat('a')
1643
packed_stat = dirstate.pack_stat(stat_value)
1645
link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
1646
self.assertIs(None, link_or_sha1)
1647
self.assertEqual([('d', '', 0, False, packed_stat)], entry[1])
1651
def create_and_test_symlink(self, state, entry):
1652
"""Create a symlink at 'a' and verify the state finds it.
1654
The state should already be versioning *something* at 'a'. This makes
1655
sure that state.update_entry recognizes it as a symlink.
1657
This should not be called if this platform does not have symlink
1660
# caller should care about skipping test on platforms without symlinks
1661
os.symlink('path/to/foo', 'a')
1663
stat_value = os.lstat('a')
1664
packed_stat = dirstate.pack_stat(stat_value)
1666
link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
1667
self.assertEqual('path/to/foo', link_or_sha1)
1668
self.assertEqual([('l', 'path/to/foo', 11, False, packed_stat)],
1672
def test_update_file_to_dir(self):
1673
"""If a file changes to a directory we return None for the sha.
1674
We also update the inventory record.
1676
state, entry = self.get_state_with_a()
1677
# The file sha1 won't be cached unless the file is old
1678
state.adjust_time(+10)
1679
self.create_and_test_file(state, entry)
1681
self.create_and_test_dir(state, entry)
1683
def test_update_file_to_symlink(self):
1684
"""File becomes a symlink"""
1685
if not osutils.has_symlinks():
1686
# PlatformDeficiency / TestSkipped
1687
raise TestSkipped("No symlink support")
1688
state, entry = self.get_state_with_a()
1689
# The file sha1 won't be cached unless the file is old
1690
state.adjust_time(+10)
1691
self.create_and_test_file(state, entry)
1693
self.create_and_test_symlink(state, entry)
1695
def test_update_dir_to_file(self):
1696
"""Directory becoming a file updates the entry."""
1697
state, entry = self.get_state_with_a()
1698
# The file sha1 won't be cached unless the file is old
1699
state.adjust_time(+10)
1700
self.create_and_test_dir(state, entry)
1702
self.create_and_test_file(state, entry)
1704
def test_update_dir_to_symlink(self):
1705
"""Directory becomes a symlink"""
1706
if not osutils.has_symlinks():
1707
# PlatformDeficiency / TestSkipped
1708
raise TestSkipped("No symlink support")
1709
state, entry = self.get_state_with_a()
1710
# The symlink target won't be cached if it isn't old
1711
state.adjust_time(+10)
1712
self.create_and_test_dir(state, entry)
1714
self.create_and_test_symlink(state, entry)
1716
def test_update_symlink_to_file(self):
1717
"""Symlink becomes a file"""
1718
if not has_symlinks():
1719
raise TestSkipped("No symlink support")
1720
state, entry = self.get_state_with_a()
1721
# The symlink and file info won't be cached unless old
1722
state.adjust_time(+10)
1723
self.create_and_test_symlink(state, entry)
1725
self.create_and_test_file(state, entry)
1727
def test_update_symlink_to_dir(self):
1728
"""Symlink becomes a directory"""
1729
if not has_symlinks():
1730
raise TestSkipped("No symlink support")
1731
state, entry = self.get_state_with_a()
1732
# The symlink target won't be cached if it isn't old
1733
state.adjust_time(+10)
1734
self.create_and_test_symlink(state, entry)
1736
self.create_and_test_dir(state, entry)
1738
def test__is_executable_win32(self):
1739
state, entry = self.get_state_with_a()
1740
self.build_tree(['a'])
1742
# Make sure we are using the win32 implementation of _is_executable
1743
state._is_executable = state._is_executable_win32
1745
# The file on disk is not executable, but we are marking it as though
1746
# it is. With _is_executable_win32 we ignore what is on disk.
1747
entry[1][0] = ('f', '', 0, True, dirstate.DirState.NULLSTAT)
1749
stat_value = os.lstat('a')
1750
packed_stat = dirstate.pack_stat(stat_value)
1752
state.adjust_time(-10) # Make sure everything is new
1753
state.update_entry(entry, abspath='a', stat_value=stat_value)
1755
# The row is updated, but the executable bit stays set.
1756
self.assertEqual([('f', '', 14, True, dirstate.DirState.NULLSTAT)],
1759
# Make the disk object look old enough to cache
1760
state.adjust_time(+20)
1761
digest = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
1762
state.update_entry(entry, abspath='a', stat_value=stat_value)
1763
self.assertEqual([('f', digest, 14, True, packed_stat)], entry[1])
1766
class TestPackStat(TestCaseWithTransport):
1746
1768
def assertPackStat(self, expected, stat_value):
1747
1769
"""Check the packed and serialized form of a stat value."""
2050
class TestBisectDirblock(TestCase):
2051
"""Test that bisect_dirblock() returns the expected values.
2053
bisect_dirblock is intended to work like bisect.bisect_left() except it
2054
knows it is working on dirblocks and that dirblocks are sorted by ('path',
2055
'to', 'foo') chunks rather than by raw 'path/to/foo'.
2058
def assertBisect(self, dirblocks, split_dirblocks, path, *args, **kwargs):
2059
"""Assert that bisect_split works like bisect_left on the split paths.
2061
:param dirblocks: A list of (path, [info]) pairs.
2062
:param split_dirblocks: A list of ((split, path), [info]) pairs.
2063
:param path: The path we are indexing.
2065
All other arguments will be passed along.
2067
bisect_split_idx = dirstate.bisect_dirblock(dirblocks, path,
2069
split_dirblock = (path.split('/'), [])
2070
bisect_left_idx = bisect.bisect_left(split_dirblocks, split_dirblock,
2072
self.assertEqual(bisect_left_idx, bisect_split_idx,
2073
'bisect_split disagreed. %s != %s'
2075
% (bisect_left_idx, bisect_split_idx, path)
2078
def paths_to_dirblocks(self, paths):
2079
"""Convert a list of paths into dirblock form.
2081
Also, ensure that the paths are in proper sorted order.
2083
dirblocks = [(path, []) for path in paths]
2084
split_dirblocks = [(path.split('/'), []) for path in paths]
2085
self.assertEqual(sorted(split_dirblocks), split_dirblocks)
2086
return dirblocks, split_dirblocks
2088
def test_simple(self):
2089
"""In the simple case it works just like bisect_left"""
2090
paths = ['', 'a', 'b', 'c', 'd']
2091
dirblocks, split_dirblocks = self.paths_to_dirblocks(paths)
2093
self.assertBisect(dirblocks, split_dirblocks, path)
2094
self.assertBisect(dirblocks, split_dirblocks, '_')
2095
self.assertBisect(dirblocks, split_dirblocks, 'aa')
2096
self.assertBisect(dirblocks, split_dirblocks, 'bb')
2097
self.assertBisect(dirblocks, split_dirblocks, 'cc')
2098
self.assertBisect(dirblocks, split_dirblocks, 'dd')
2099
self.assertBisect(dirblocks, split_dirblocks, 'a/a')
2100
self.assertBisect(dirblocks, split_dirblocks, 'b/b')
2101
self.assertBisect(dirblocks, split_dirblocks, 'c/c')
2102
self.assertBisect(dirblocks, split_dirblocks, 'd/d')
2104
def test_involved(self):
2105
"""This is where bisect_left diverges slightly."""
2107
'a/a', 'a/a/a', 'a/a/z', 'a/a-a', 'a/a-z',
2108
'a/z', 'a/z/a', 'a/z/z', 'a/z-a', 'a/z-z',
2110
'z', 'z/a/a', 'z/a/z', 'z/a-a', 'z/a-z',
2111
'z/z', 'z/z/a', 'z/z/z', 'z/z-a', 'z/z-z',
2114
dirblocks, split_dirblocks = self.paths_to_dirblocks(paths)
2116
self.assertBisect(dirblocks, split_dirblocks, path)
2118
def test_involved_cached(self):
2119
"""This is where bisect_left diverges slightly."""
2121
'a/a', 'a/a/a', 'a/a/z', 'a/a-a', 'a/a-z',
2122
'a/z', 'a/z/a', 'a/z/z', 'a/z-a', 'a/z-z',
2124
'z', 'z/a/a', 'z/a/z', 'z/a-a', 'z/a-z',
2125
'z/z', 'z/z/a', 'z/z/z', 'z/z-a', 'z/z-z',
2129
dirblocks, split_dirblocks = self.paths_to_dirblocks(paths)
2131
self.assertBisect(dirblocks, split_dirblocks, path, cache=cache)
2035
2134
class TestDirstateValidation(TestCaseWithDirState):
2037
2136
def test_validate_correct_dirstate(self):
2087
2186
state._validate)
2088
2187
self.assertContainsRe(str(e),
2089
2188
'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)
added
removed
bzrlib/tests/test_dirstate.py
