29
from bzrlib.tests import (
35
from bzrlib import _dirstate_helpers_pyx
36
has_dirstate_helpers_pyx = True
38
has_dirstate_helpers_pyx = False
41
compiled_dirstate_helpers_feature = tests.ModuleAvailableFeature(
42
'bzrlib._dirstate_helpers_pyx')
45
def load_tests(basic_tests, module, loader):
46
# FIXME: we should also parametrize against SHA1Provider !
47
suite = loader.suiteClass()
48
remaining_tests = basic_tests
50
dir_reader_scenarios = test_osutils.dir_reader_scenarios()
52
ue_scenarios = [('dirstate_Python',
53
{'update_entry': dirstate.py_update_entry})]
54
if compiled_dirstate_helpers_feature.available():
55
update_entry = compiled_dirstate_helpers_feature.module.update_entry
56
pyrex_scenario = ('dirstate_Pyrex', {'update_entry': update_entry})
57
ue_scenarios.append(pyrex_scenario)
58
process_entry_tests, remaining_tests = tests.split_suite_by_condition(
59
remaining_tests, tests.condition_isinstance(TestUpdateEntry))
60
tests.multiply_tests(process_entry_tests,
61
tests.multiply_scenarios(dir_reader_scenarios,
65
pe_scenarios = [('dirstate_Python',
66
{'_process_entry': dirstate.ProcessEntryPython})]
67
if compiled_dirstate_helpers_feature.available():
68
process_entry = compiled_dirstate_helpers_feature.module.ProcessEntryC
69
pyrex_scenario = ('dirstate_Pyrex', {'_process_entry': process_entry})
70
pe_scenarios.append(pyrex_scenario)
71
process_entry_tests, remaining_tests = tests.split_suite_by_condition(
72
remaining_tests, tests.condition_isinstance(TestProcessEntry))
73
tests.multiply_tests(process_entry_tests,
74
tests.multiply_scenarios(dir_reader_scenarios,
78
dir_reader_tests, remaining_tests = tests.split_suite_by_condition(
79
remaining_tests, tests.condition_isinstance(
80
test_dirstate.TestCaseWithDirState))
81
tests.multiply_tests(dir_reader_tests, dir_reader_scenarios, suite)
82
suite.addTest(remaining_tests)
35
from .test_osutils import dir_reader_scenarios
36
from .scenarios import (
37
load_tests_apply_scenarios,
45
load_tests = load_tests_apply_scenarios
48
compiled_dirstate_helpers_feature = features.ModuleAvailableFeature(
49
'breezy.bzr._dirstate_helpers_pyx')
52
# FIXME: we should also parametrize against SHA1Provider !
54
ue_scenarios = [('dirstate_Python',
55
{'update_entry': dirstate.py_update_entry})]
56
if compiled_dirstate_helpers_feature.available():
57
update_entry = compiled_dirstate_helpers_feature.module.update_entry
58
ue_scenarios.append(('dirstate_Pyrex', {'update_entry': update_entry}))
60
pe_scenarios = [('dirstate_Python',
61
{'_process_entry': dirstate.ProcessEntryPython})]
62
if compiled_dirstate_helpers_feature.available():
63
process_entry = compiled_dirstate_helpers_feature.module.ProcessEntryC
64
pe_scenarios.append(('dirstate_Pyrex', {'_process_entry': process_entry}))
66
helper_scenarios = [('dirstate_Python', {'helpers': _dirstate_helpers_py})]
67
if compiled_dirstate_helpers_feature.available():
68
helper_scenarios.append(('dirstate_Pyrex',
69
{'helpers': compiled_dirstate_helpers_feature.module}))
87
72
class TestBisectPathMixin(object):
389
374
_test_needs_features = [compiled_dirstate_helpers_feature]
391
376
def get_bisect_dirblock(self):
392
from bzrlib._dirstate_helpers_pyx import bisect_dirblock
377
from breezy.bzr._dirstate_helpers_pyx import bisect_dirblock
393
378
return bisect_dirblock
396
class TestCmpByDirs(tests.TestCase):
397
"""Test an implementation of cmp_by_dirs()
381
class TestLtByDirs(tests.TestCase):
382
"""Test an implementation of lt_by_dirs()
399
cmp_by_dirs() compares 2 paths by their directory sections, rather than as
384
lt_by_dirs() compares 2 paths by their directory sections, rather than as
402
Child test cases can override ``get_cmp_by_dirs`` to test a specific
387
Child test cases can override ``get_lt_by_dirs`` to test a specific
406
def get_cmp_by_dirs(self):
407
"""Get a specific implementation of cmp_by_dirs."""
408
from bzrlib._dirstate_helpers_py import cmp_by_dirs
391
def get_lt_by_dirs(self):
392
"""Get a specific implementation of lt_by_dirs."""
393
from ..bzr._dirstate_helpers_py import lt_by_dirs
411
396
def assertCmpByDirs(self, expected, str1, str2):
412
397
"""Compare the two strings, in both directions.
416
401
:param str1: string to compare
417
402
:param str2: string to compare
419
cmp_by_dirs = self.get_cmp_by_dirs()
404
lt_by_dirs = self.get_lt_by_dirs()
420
405
if expected == 0:
421
406
self.assertEqual(str1, str2)
422
self.assertEqual(0, cmp_by_dirs(str1, str2))
423
self.assertEqual(0, cmp_by_dirs(str2, str1))
407
self.assertFalse(lt_by_dirs(str1, str2))
408
self.assertFalse(lt_by_dirs(str2, str1))
424
409
elif expected > 0:
425
self.assertPositive(cmp_by_dirs(str1, str2))
426
self.assertNegative(cmp_by_dirs(str2, str1))
410
self.assertFalse(lt_by_dirs(str1, str2))
411
self.assertTrue(lt_by_dirs(str2, str1))
428
self.assertNegative(cmp_by_dirs(str1, str2))
429
self.assertPositive(cmp_by_dirs(str2, str1))
413
self.assertTrue(lt_by_dirs(str1, str2))
414
self.assertFalse(lt_by_dirs(str2, str1))
431
416
def test_cmp_empty(self):
432
417
"""Compare against the empty string."""
492
477
self.assertCmpByDirs(-1, 'ab/cd', 'ab-cd')
494
479
def test_cmp_unicode_not_allowed(self):
495
cmp_by_dirs = self.get_cmp_by_dirs()
496
self.assertRaises(TypeError, cmp_by_dirs, u'Unicode', 'str')
497
self.assertRaises(TypeError, cmp_by_dirs, 'str', u'Unicode')
498
self.assertRaises(TypeError, cmp_by_dirs, u'Unicode', u'Unicode')
480
lt_by_dirs = self.get_lt_by_dirs()
481
self.assertRaises(TypeError, lt_by_dirs, u'Unicode', 'str')
482
self.assertRaises(TypeError, lt_by_dirs, 'str', u'Unicode')
483
self.assertRaises(TypeError, lt_by_dirs, u'Unicode', u'Unicode')
500
485
def test_cmp_non_ascii(self):
501
486
self.assertCmpByDirs(-1, '\xc2\xb5', '\xc3\xa5') # u'\xb5', u'\xe5'
505
490
self.assertCmpByDirs(-1, 'b/a', 'b/\xc2\xb5') # u'b/a', u'b/\xb5'
508
class TestCompiledCmpByDirs(TestCmpByDirs):
509
"""Test the pyrex implementation of cmp_by_dirs"""
493
class TestCompiledLtByDirs(TestLtByDirs):
494
"""Test the pyrex implementation of lt_by_dirs"""
511
496
_test_needs_features = [compiled_dirstate_helpers_feature]
513
def get_cmp_by_dirs(self):
514
from bzrlib._dirstate_helpers_pyx import cmp_by_dirs
518
class TestCmpPathByDirblock(tests.TestCase):
519
"""Test an implementation of _cmp_path_by_dirblock()
521
_cmp_path_by_dirblock() compares two paths using the sort order used by
498
def get_lt_by_dirs(self):
499
from ..bzr._dirstate_helpers_pyx import lt_by_dirs
503
class TestLtPathByDirblock(tests.TestCase):
504
"""Test an implementation of _lt_path_by_dirblock()
506
_lt_path_by_dirblock() compares two paths using the sort order used by
522
507
DirState. All paths in the same directory are sorted together.
524
Child test cases can override ``get_cmp_path_by_dirblock`` to test a specific
509
Child test cases can override ``get_lt_path_by_dirblock`` to test a specific
528
def get_cmp_path_by_dirblock(self):
529
"""Get a specific implementation of _cmp_path_by_dirblock."""
530
from bzrlib._dirstate_helpers_py import _cmp_path_by_dirblock
531
return _cmp_path_by_dirblock
513
def get_lt_path_by_dirblock(self):
514
"""Get a specific implementation of _lt_path_by_dirblock."""
515
from ..bzr._dirstate_helpers_py import _lt_path_by_dirblock
516
return _lt_path_by_dirblock
533
def assertCmpPathByDirblock(self, paths):
518
def assertLtPathByDirblock(self, paths):
534
519
"""Compare all paths and make sure they evaluate to the correct order.
536
521
This does N^2 comparisons. It is assumed that ``paths`` is properly
544
529
return dirname.split('/'), basename
545
530
self.assertEqual(sorted(paths, key=_key), paths)
547
cmp_path_by_dirblock = self.get_cmp_path_by_dirblock()
532
lt_path_by_dirblock = self.get_lt_path_by_dirblock()
548
533
for idx1, path1 in enumerate(paths):
549
534
for idx2, path2 in enumerate(paths):
550
cmp_val = cmp_path_by_dirblock(path1, path2)
552
self.assertTrue(cmp_val < 0,
553
'%s did not state that %r came before %r, cmp=%s'
554
% (cmp_path_by_dirblock.__name__,
555
path1, path2, cmp_val))
557
self.assertTrue(cmp_val > 0,
558
'%s did not state that %r came after %r, cmp=%s'
559
% (cmp_path_by_dirblock.__name__,
560
path1, path2, cmp_val))
562
self.assertTrue(cmp_val == 0,
563
'%s did not state that %r == %r, cmp=%s'
564
% (cmp_path_by_dirblock.__name__,
565
path1, path2, cmp_val))
535
lt_result = lt_path_by_dirblock(path1, path2)
536
self.assertEqual(idx1 < idx2, lt_result,
537
'%s did not state that %r < %r, lt=%s'
538
% (lt_path_by_dirblock.__name__,
539
path1, path2, lt_result))
567
541
def test_cmp_simple_paths(self):
568
542
"""Compare against the empty string."""
569
self.assertCmpPathByDirblock(['', 'a', 'ab', 'abc', 'a/b/c', 'b/d/e'])
570
self.assertCmpPathByDirblock(['kl', 'ab/cd', 'ab/ef', 'gh/ij'])
543
self.assertLtPathByDirblock(['', 'a', 'ab', 'abc', 'a/b/c', 'b/d/e'])
544
self.assertLtPathByDirblock(['kl', 'ab/cd', 'ab/ef', 'gh/ij'])
572
546
def test_tricky_paths(self):
573
self.assertCmpPathByDirblock([
547
self.assertLtPathByDirblock([
575
549
'', 'a', 'a-a', 'a=a', 'b',
576
550
# Contents of 'a'
631
605
def test_unicode_not_allowed(self):
632
cmp_path_by_dirblock = self.get_cmp_path_by_dirblock()
633
self.assertRaises(TypeError, cmp_path_by_dirblock, u'Uni', 'str')
634
self.assertRaises(TypeError, cmp_path_by_dirblock, 'str', u'Uni')
635
self.assertRaises(TypeError, cmp_path_by_dirblock, u'Uni', u'Uni')
636
self.assertRaises(TypeError, cmp_path_by_dirblock, u'x/Uni', 'x/str')
637
self.assertRaises(TypeError, cmp_path_by_dirblock, 'x/str', u'x/Uni')
638
self.assertRaises(TypeError, cmp_path_by_dirblock, u'x/Uni', u'x/Uni')
606
lt_path_by_dirblock = self.get_lt_path_by_dirblock()
607
self.assertRaises(TypeError, lt_path_by_dirblock, u'Uni', 'str')
608
self.assertRaises(TypeError, lt_path_by_dirblock, 'str', u'Uni')
609
self.assertRaises(TypeError, lt_path_by_dirblock, u'Uni', u'Uni')
610
self.assertRaises(TypeError, lt_path_by_dirblock, u'x/Uni', 'x/str')
611
self.assertRaises(TypeError, lt_path_by_dirblock, 'x/str', u'x/Uni')
612
self.assertRaises(TypeError, lt_path_by_dirblock, u'x/Uni', u'x/Uni')
640
614
def test_nonascii(self):
641
self.assertCmpPathByDirblock([
615
self.assertLtPathByDirblock([
643
617
'', 'a', '\xc2\xb5', '\xc3\xa5',
775
751
def test_bisect_dirblock(self):
776
752
if compiled_dirstate_helpers_feature.available():
777
from bzrlib._dirstate_helpers_pyx import bisect_dirblock
753
from breezy.bzr._dirstate_helpers_pyx import bisect_dirblock
779
from bzrlib._dirstate_helpers_py import bisect_dirblock
755
from breezy.bzr._dirstate_helpers_py import bisect_dirblock
780
756
self.assertIs(bisect_dirblock, dirstate.bisect_dirblock)
782
758
def test__bisect_path_left(self):
783
759
if compiled_dirstate_helpers_feature.available():
784
from bzrlib._dirstate_helpers_pyx import _bisect_path_left
760
from breezy.bzr._dirstate_helpers_pyx import _bisect_path_left
786
from bzrlib._dirstate_helpers_py import _bisect_path_left
762
from breezy.bzr._dirstate_helpers_py import _bisect_path_left
787
763
self.assertIs(_bisect_path_left, dirstate._bisect_path_left)
789
765
def test__bisect_path_right(self):
790
766
if compiled_dirstate_helpers_feature.available():
791
from bzrlib._dirstate_helpers_pyx import _bisect_path_right
767
from breezy.bzr._dirstate_helpers_pyx import _bisect_path_right
793
from bzrlib._dirstate_helpers_py import _bisect_path_right
769
from breezy.bzr._dirstate_helpers_py import _bisect_path_right
794
770
self.assertIs(_bisect_path_right, dirstate._bisect_path_right)
796
def test_cmp_by_dirs(self):
772
def test_lt_by_dirs(self):
797
773
if compiled_dirstate_helpers_feature.available():
798
from bzrlib._dirstate_helpers_pyx import cmp_by_dirs
774
from ..bzr._dirstate_helpers_pyx import lt_by_dirs
800
from bzrlib._dirstate_helpers_py import cmp_by_dirs
801
self.assertIs(cmp_by_dirs, dirstate.cmp_by_dirs)
776
from ..bzr._dirstate_helpers_py import lt_by_dirs
777
self.assertIs(lt_by_dirs, dirstate.lt_by_dirs)
803
779
def test__read_dirblocks(self):
804
780
if compiled_dirstate_helpers_feature.available():
805
from bzrlib._dirstate_helpers_pyx import _read_dirblocks
781
from breezy.bzr._dirstate_helpers_pyx import _read_dirblocks
807
from bzrlib._dirstate_helpers_py import _read_dirblocks
783
from breezy.bzr._dirstate_helpers_py import _read_dirblocks
808
784
self.assertIs(_read_dirblocks, dirstate._read_dirblocks)
810
786
def test_update_entry(self):
811
787
if compiled_dirstate_helpers_feature.available():
812
from bzrlib._dirstate_helpers_pyx import update_entry
788
from breezy.bzr._dirstate_helpers_pyx import update_entry
814
from bzrlib.dirstate import update_entry
790
from breezy.bzr.dirstate import update_entry
815
791
self.assertIs(update_entry, dirstate.update_entry)
817
793
def test_process_entry(self):
818
794
if compiled_dirstate_helpers_feature.available():
819
from bzrlib._dirstate_helpers_pyx import ProcessEntryC
795
from breezy.bzr._dirstate_helpers_pyx import ProcessEntryC
820
796
self.assertIs(ProcessEntryC, dirstate._process_entry)
822
from bzrlib.dirstate import ProcessEntryPython
798
from breezy.bzr.dirstate import ProcessEntryPython
823
799
self.assertIs(ProcessEntryPython, dirstate._process_entry)
826
802
class TestUpdateEntry(test_dirstate.TestCaseWithDirState):
827
803
"""Test the DirState.update_entry functions"""
805
scenarios = multiply_scenarios(
806
dir_reader_scenarios(), ue_scenarios)
829
808
# Set by load_tests
830
809
update_entry = None
844
823
def test_observed_sha1_cachable(self):
845
824
state, entry = self.get_state_with_a()
846
826
atime = time.time() - 10
847
827
self.build_tree(['a'])
848
statvalue = os.lstat('a')
849
statvalue = test_dirstate._FakeStat(statvalue.st_size, atime, atime,
850
statvalue.st_dev, statvalue.st_ino, statvalue.st_mode)
828
statvalue = test_dirstate._FakeStat.from_stat(os.lstat('a'))
829
statvalue.st_mtime = statvalue.st_ctime = atime
830
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
831
state._dirblock_state)
851
832
state._observed_sha1(entry, "foo", statvalue)
852
833
self.assertEqual('foo', entry[1][0][1])
853
834
packed_stat = dirstate.pack_stat(statvalue)
854
835
self.assertEqual(packed_stat, entry[1][0][4])
836
self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
837
state._dirblock_state)
856
839
def test_observed_sha1_not_cachable(self):
857
840
state, entry = self.get_state_with_a()
858
842
oldval = entry[1][0][1]
859
843
oldstat = entry[1][0][4]
860
844
self.build_tree(['a'])
861
845
statvalue = os.lstat('a')
846
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
847
state._dirblock_state)
862
848
state._observed_sha1(entry, "foo", statvalue)
863
849
self.assertEqual(oldval, entry[1][0][1])
864
850
self.assertEqual(oldstat, entry[1][0][4])
851
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
852
state._dirblock_state)
866
854
def test_update_entry(self):
867
855
state, _ = self.get_state_with_a()
892
880
stat_value=stat_value)
893
881
self.assertEqual(None, link_or_sha1)
895
# The dirblock entry should not have cached the file's sha1 (too new)
883
# The dirblock entry should not have computed or cached the file's
884
# sha1, but it did update the files' st_size. However, this is not
885
# worth writing a dirstate file for, so we leave the state UNMODIFIED
896
886
self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
898
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
888
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
899
889
state._dirblock_state)
900
890
mode = stat_value.st_mode
901
891
self.assertEqual([('is_exec', mode, False)], state._log)
977
968
# Dirblock is not updated (the link is too new)
978
969
self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
980
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
971
# The file entry turned into a symlink, that is considered
972
# HASH modified worthy.
973
self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
981
974
state._dirblock_state)
983
976
# Because the stat_value looks new, we should re-read the target
984
978
link_or_sha1 = self.update_entry(state, entry, abspath='a',
985
979
stat_value=stat_value)
986
980
self.assertEqual('target', link_or_sha1)
987
self.assertEqual([('read_link', 'a', ''),
988
('read_link', 'a', ''),
981
self.assertEqual([('read_link', 'a', '')], state._log)
990
982
self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
992
985
state.adjust_time(+20) # Skip into the future, all files look old
993
987
link_or_sha1 = self.update_entry(state, entry, abspath='a',
994
988
stat_value=stat_value)
989
# The symlink stayed a symlink. So while it is new enough to cache, we
990
# don't bother setting the flag, because it is not really worth saving
991
# (when we stat the symlink, we'll have paged in the target.)
992
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
993
state._dirblock_state)
995
994
self.assertEqual('target', link_or_sha1)
996
995
# We need to re-read the link because only now can we cache it
997
self.assertEqual([('read_link', 'a', ''),
998
('read_link', 'a', ''),
999
('read_link', 'a', ''),
996
self.assertEqual([('read_link', 'a', '')], state._log)
1001
997
self.assertEqual([('l', 'target', 6, False, packed_stat)],
1004
1001
# Another call won't re-read the link
1005
self.assertEqual([('read_link', 'a', ''),
1006
('read_link', 'a', ''),
1007
('read_link', 'a', ''),
1002
self.assertEqual([], state._log)
1009
1003
link_or_sha1 = self.update_entry(state, entry, abspath='a',
1010
1004
stat_value=stat_value)
1011
1005
self.assertEqual('target', link_or_sha1)
1026
1020
self.build_tree(['a/'])
1027
1021
state.adjust_time(+20)
1028
1022
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1023
# a/ used to be a file, but is now a directory, worth saving
1029
1024
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1030
1025
state._dirblock_state)
1032
1027
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1033
1028
state._dirblock_state)
1034
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1029
# No changes to a/ means not worth saving.
1030
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1031
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1032
state._dirblock_state)
1033
# Change the last-modified time for the directory
1034
t = time.time() - 100.0
1036
os.utime('a', (t, t))
1038
# It looks like Win32 + FAT doesn't allow to change times on a dir.
1039
raise tests.TestSkipped("can't update mtime of a dir on FAT")
1040
saved_packed_stat = entry[1][0][-1]
1041
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1042
# We *do* go ahead and update the information in the dirblocks, but we
1043
# don't bother setting IN_MEMORY_MODIFIED because it is trivial to
1045
self.assertNotEqual(saved_packed_stat, entry[1][0][-1])
1035
1046
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1036
1047
state._dirblock_state)
1321
1334
state._sha1_provider = UppercaseSHA1Provider()
1322
1335
self.assertChangedFileIds(['file-id'], tree)
1338
class TestPackStat(tests.TestCase):
1339
"""Check packed representaton of stat values is robust on all inputs"""
1341
scenarios = helper_scenarios
1343
def pack(self, statlike_tuple):
1344
return self.helpers.pack_stat(os.stat_result(statlike_tuple))
1347
def unpack_field(packed_string, stat_field):
1348
return _dirstate_helpers_py._unpack_stat(packed_string)[stat_field]
1350
def test_result(self):
1351
self.assertEqual("AAAQAAAAABAAAAARAAAAAgAAAAEAAIHk",
1352
self.pack((33252, 1, 2, 0, 0, 0, 4096, 15.5, 16.5, 17.5)))
1354
def test_giant_inode(self):
1355
packed = self.pack((33252, 0xF80000ABC, 0, 0, 0, 0, 0, 0, 0, 0))
1356
self.assertEqual(0x80000ABC, self.unpack_field(packed, "st_ino"))
1358
def test_giant_size(self):
1359
packed = self.pack((33252, 0, 0, 0, 0, 0, (1 << 33) + 4096, 0, 0, 0))
1360
self.assertEqual(4096, self.unpack_field(packed, "st_size"))
1362
def test_fractional_mtime(self):
1363
packed = self.pack((33252, 0, 0, 0, 0, 0, 0, 0, 16.9375, 0))
1364
self.assertEqual(16, self.unpack_field(packed, "st_mtime"))
1366
def test_ancient_mtime(self):
1367
packed = self.pack((33252, 0, 0, 0, 0, 0, 0, 0, -11644473600.0, 0))
1368
self.assertEqual(1240428288, self.unpack_field(packed, "st_mtime"))
1370
def test_distant_mtime(self):
1371
packed = self.pack((33252, 0, 0, 0, 0, 0, 0, 0, 64060588800.0, 0))
1372
self.assertEqual(3931046656, self.unpack_field(packed, "st_mtime"))
1374
def test_fractional_ctime(self):
1375
packed = self.pack((33252, 0, 0, 0, 0, 0, 0, 0, 0, 17.5625))
1376
self.assertEqual(17, self.unpack_field(packed, "st_ctime"))
1378
def test_ancient_ctime(self):
1379
packed = self.pack((33252, 0, 0, 0, 0, 0, 0, 0, 0, -11644473600.0))
1380
self.assertEqual(1240428288, self.unpack_field(packed, "st_ctime"))
1382
def test_distant_ctime(self):
1383
packed = self.pack((33252, 0, 0, 0, 0, 0, 0, 0, 0, 64060588800.0))
1384
self.assertEqual(3931046656, self.unpack_field(packed, "st_ctime"))
1386
def test_negative_dev(self):
1387
packed = self.pack((33252, 0, -0xFFFFFCDE, 0, 0, 0, 0, 0, 0, 0))
1388
self.assertEqual(0x322, self.unpack_field(packed, "st_dev"))
added
removed
breezy/tests/test__dirstate_helpers.py
