Mercurial > public > mercurial-scm > hg

comparison mercurial/testing/storage.py @ 47012:d55b71393907

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
node: replace nullid and friends with nodeconstants class The introduction of 256bit hashes require changes to nullid and other constant magic values. Start pushing them down from repository and revlog where sensible. Differential Revision: https://phab.mercurial-scm.org/D9465
author Joerg Sonnenberger <joerg@bec.de>
date Mon, 29 Mar 2021 01:52:06 +0200
parents e8c11a2c96c0
children 6000f5b25c9b
comparison
equal deleted inserted replaced
46992:5fa019ceb499 47012:d55b71393907
9 9
10 import unittest 10 import unittest
11 11
12 from ..node import ( 12 from ..node import (
13 hex, 13 hex,
14 nullid,
15 nullrev, 14 nullrev,
16 ) 15 )
17 from ..pycompat import getattr 16 from ..pycompat import getattr
18 from .. import ( 17 from .. import (
19 error, 18 error,
49 next(gen) 48 next(gen)
50 49
51 self.assertFalse(f.hasnode(None)) 50 self.assertFalse(f.hasnode(None))
52 self.assertFalse(f.hasnode(0)) 51 self.assertFalse(f.hasnode(0))
53 self.assertFalse(f.hasnode(nullrev)) 52 self.assertFalse(f.hasnode(nullrev))
54 self.assertFalse(f.hasnode(nullid)) 53 self.assertFalse(f.hasnode(f.nullid))
55 self.assertFalse(f.hasnode(b'0')) 54 self.assertFalse(f.hasnode(b'0'))
56 self.assertFalse(f.hasnode(b'a' * 20)) 55 self.assertFalse(f.hasnode(b'a' * 20))
57 56
58 # revs() should evaluate to an empty list. 57 # revs() should evaluate to an empty list.
59 self.assertEqual(list(f.revs()), []) 58 self.assertEqual(list(f.revs()), [])
62 with self.assertRaises(StopIteration): 61 with self.assertRaises(StopIteration):
63 next(revs) 62 next(revs)
64 63
65 self.assertEqual(list(f.revs(start=20)), []) 64 self.assertEqual(list(f.revs(start=20)), [])
66 65
67 # parents() and parentrevs() work with nullid/nullrev. 66 # parents() and parentrevs() work with f.nullid/nullrev.
68 self.assertEqual(f.parents(nullid), (nullid, nullid)) 67 self.assertEqual(f.parents(f.nullid), (f.nullid, f.nullid))
69 self.assertEqual(f.parentrevs(nullrev), (nullrev, nullrev)) 68 self.assertEqual(f.parentrevs(nullrev), (nullrev, nullrev))
70 69
71 with self.assertRaises(error.LookupError): 70 with self.assertRaises(error.LookupError):
72 f.parents(b'\x01' * 20) 71 f.parents(b'\x01' * 20)
73 72
76 continue 75 continue
77 76
78 with self.assertRaises(IndexError): 77 with self.assertRaises(IndexError):
79 f.parentrevs(i) 78 f.parentrevs(i)
80 79
81 # nullid/nullrev lookup always works. 80 # f.nullid/nullrev lookup always works.
82 self.assertEqual(f.rev(nullid), nullrev) 81 self.assertEqual(f.rev(f.nullid), nullrev)
83 self.assertEqual(f.node(nullrev), nullid) 82 self.assertEqual(f.node(nullrev), f.nullid)
84 83
85 with self.assertRaises(error.LookupError): 84 with self.assertRaises(error.LookupError):
86 f.rev(b'\x01' * 20) 85 f.rev(b'\x01' * 20)
87 86
88 for i in range(-5, 5): 87 for i in range(-5, 5):
90 continue 89 continue
91 90
92 with self.assertRaises(IndexError): 91 with self.assertRaises(IndexError):
93 f.node(i) 92 f.node(i)
94 93
95 self.assertEqual(f.lookup(nullid), nullid) 94 self.assertEqual(f.lookup(f.nullid), f.nullid)
96 self.assertEqual(f.lookup(nullrev), nullid) 95 self.assertEqual(f.lookup(nullrev), f.nullid)
97 self.assertEqual(f.lookup(hex(nullid)), nullid) 96 self.assertEqual(f.lookup(hex(f.nullid)), f.nullid)
98 self.assertEqual(f.lookup(b'%d' % nullrev), nullid) 97 self.assertEqual(f.lookup(b'%d' % nullrev), f.nullid)
99 98
100 with self.assertRaises(error.LookupError): 99 with self.assertRaises(error.LookupError):
101 f.lookup(b'badvalue') 100 f.lookup(b'badvalue')
102 101
103 with self.assertRaises(error.LookupError): 102 with self.assertRaises(error.LookupError):
104 f.lookup(hex(nullid)[0:12]) 103 f.lookup(hex(f.nullid)[0:12])
105 104
106 with self.assertRaises(error.LookupError): 105 with self.assertRaises(error.LookupError):
107 f.lookup(b'-2') 106 f.lookup(b'-2')
108 107
109 with self.assertRaises(error.LookupError): 108 with self.assertRaises(error.LookupError):
138 continue 137 continue
139 138
140 with self.assertRaises(IndexError): 139 with self.assertRaises(IndexError):
141 f.iscensored(i) 140 f.iscensored(i)
142 141
143 self.assertEqual(list(f.commonancestorsheads(nullid, nullid)), []) 142 self.assertEqual(list(f.commonancestorsheads(f.nullid, f.nullid)), [])
144 143
145 with self.assertRaises(ValueError): 144 with self.assertRaises(ValueError):
146 self.assertEqual(list(f.descendants([])), []) 145 self.assertEqual(list(f.descendants([])), [])
147 146
148 self.assertEqual(list(f.descendants([nullrev])), []) 147 self.assertEqual(list(f.descendants([nullrev])), [])
149 148
150 self.assertEqual(f.heads(), [nullid]) 149 self.assertEqual(f.heads(), [f.nullid])
151 self.assertEqual(f.heads(nullid), [nullid]) 150 self.assertEqual(f.heads(f.nullid), [f.nullid])
152 self.assertEqual(f.heads(None, [nullid]), [nullid]) 151 self.assertEqual(f.heads(None, [f.nullid]), [f.nullid])
153 self.assertEqual(f.heads(nullid, [nullid]), [nullid]) 152 self.assertEqual(f.heads(f.nullid, [f.nullid]), [f.nullid])
154 153
155 self.assertEqual(f.children(nullid), []) 154 self.assertEqual(f.children(f.nullid), [])
156 155
157 with self.assertRaises(error.LookupError): 156 with self.assertRaises(error.LookupError):
158 f.children(b'\x01' * 20) 157 f.children(b'\x01' * 20)
159 158
160 def testsinglerevision(self): 159 def testsinglerevision(self):
161 f = self._makefilefn() 160 f = self._makefilefn()
162 with self._maketransactionfn() as tr: 161 with self._maketransactionfn() as tr:
163 node = f.add(b'initial', None, tr, 0, nullid, nullid) 162 node = f.add(b'initial', None, tr, 0, f.nullid, f.nullid)
164 163
165 self.assertEqual(len(f), 1) 164 self.assertEqual(len(f), 1)
166 self.assertEqual(list(f), [0]) 165 self.assertEqual(list(f), [0])
167 166
168 gen = iter(f) 167 gen = iter(f)
172 next(gen) 171 next(gen)
173 172
174 self.assertTrue(f.hasnode(node)) 173 self.assertTrue(f.hasnode(node))
175 self.assertFalse(f.hasnode(hex(node))) 174 self.assertFalse(f.hasnode(hex(node)))
176 self.assertFalse(f.hasnode(nullrev)) 175 self.assertFalse(f.hasnode(nullrev))
177 self.assertFalse(f.hasnode(nullid)) 176 self.assertFalse(f.hasnode(f.nullid))
178 self.assertFalse(f.hasnode(node[0:12])) 177 self.assertFalse(f.hasnode(node[0:12]))
179 self.assertFalse(f.hasnode(hex(node)[0:20])) 178 self.assertFalse(f.hasnode(hex(node)[0:20]))
180 179
181 self.assertEqual(list(f.revs()), [0]) 180 self.assertEqual(list(f.revs()), [0])
182 self.assertEqual(list(f.revs(start=1)), []) 181 self.assertEqual(list(f.revs(start=1)), [])
186 self.assertEqual(list(f.revs(1, 1)), []) 185 self.assertEqual(list(f.revs(1, 1)), [])
187 # TODO buggy 186 # TODO buggy
188 self.assertEqual(list(f.revs(1, 0)), [1, 0]) 187 self.assertEqual(list(f.revs(1, 0)), [1, 0])
189 self.assertEqual(list(f.revs(2, 0)), [2, 1, 0]) 188 self.assertEqual(list(f.revs(2, 0)), [2, 1, 0])
190 189
191 self.assertEqual(f.parents(node), (nullid, nullid)) 190 self.assertEqual(f.parents(node), (f.nullid, f.nullid))
192 self.assertEqual(f.parentrevs(0), (nullrev, nullrev)) 191 self.assertEqual(f.parentrevs(0), (nullrev, nullrev))
193 192
194 with self.assertRaises(error.LookupError): 193 with self.assertRaises(error.LookupError):
195 f.parents(b'\x01' * 20) 194 f.parents(b'\x01' * 20)
196 195
207 with self.assertRaises(IndexError): 206 with self.assertRaises(IndexError):
208 f.node(1) 207 f.node(1)
209 208
210 self.assertEqual(f.lookup(node), node) 209 self.assertEqual(f.lookup(node), node)
211 self.assertEqual(f.lookup(0), node) 210 self.assertEqual(f.lookup(0), node)
212 self.assertEqual(f.lookup(-1), nullid) 211 self.assertEqual(f.lookup(-1), f.nullid)
213 self.assertEqual(f.lookup(b'0'), node) 212 self.assertEqual(f.lookup(b'0'), node)
214 self.assertEqual(f.lookup(hex(node)), node) 213 self.assertEqual(f.lookup(hex(node)), node)
215 214
216 with self.assertRaises(error.LookupError): 215 with self.assertRaises(error.LookupError):
217 f.lookup(hex(node)[0:12]) 216 f.lookup(hex(node)[0:12])
254 fulltext1 = fulltext0 + b'y' 253 fulltext1 = fulltext0 + b'y'
255 fulltext2 = b'y' + fulltext0 + b'z' 254 fulltext2 = b'y' + fulltext0 + b'z'
256 255
257 f = self._makefilefn() 256 f = self._makefilefn()
258 with self._maketransactionfn() as tr: 257 with self._maketransactionfn() as tr:
259 node0 = f.add(fulltext0, None, tr, 0, nullid, nullid) 258 node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid)
260 node1 = f.add(fulltext1, None, tr, 1, node0, nullid) 259 node1 = f.add(fulltext1, None, tr, 1, node0, f.nullid)
261 node2 = f.add(fulltext2, None, tr, 3, node1, nullid) 260 node2 = f.add(fulltext2, None, tr, 3, node1, f.nullid)
262 261
263 self.assertEqual(len(f), 3) 262 self.assertEqual(len(f), 3)
264 self.assertEqual(list(f), [0, 1, 2]) 263 self.assertEqual(list(f), [0, 1, 2])
265 264
266 gen = iter(f) 265 gen = iter(f)
282 self.assertEqual(list(f.revs(2, 0)), [2, 1, 0]) 281 self.assertEqual(list(f.revs(2, 0)), [2, 1, 0])
283 self.assertEqual(list(f.revs(2, 1)), [2, 1]) 282 self.assertEqual(list(f.revs(2, 1)), [2, 1])
284 # TODO this is wrong 283 # TODO this is wrong
285 self.assertEqual(list(f.revs(3, 2)), [3, 2]) 284 self.assertEqual(list(f.revs(3, 2)), [3, 2])
286 285
287 self.assertEqual(f.parents(node0), (nullid, nullid)) 286 self.assertEqual(f.parents(node0), (f.nullid, f.nullid))
288 self.assertEqual(f.parents(node1), (node0, nullid)) 287 self.assertEqual(f.parents(node1), (node0, f.nullid))
289 self.assertEqual(f.parents(node2), (node1, nullid)) 288 self.assertEqual(f.parents(node2), (node1, f.nullid))
290 289
291 self.assertEqual(f.parentrevs(0), (nullrev, nullrev)) 290 self.assertEqual(f.parentrevs(0), (nullrev, nullrev))
292 self.assertEqual(f.parentrevs(1), (0, nullrev)) 291 self.assertEqual(f.parentrevs(1), (0, nullrev))
293 self.assertEqual(f.parentrevs(2), (1, nullrev)) 292 self.assertEqual(f.parentrevs(2), (1, nullrev))
294 293
328 self.assertFalse(f.iscensored(2)) 327 self.assertFalse(f.iscensored(2))
329 328
330 with self.assertRaises(IndexError): 329 with self.assertRaises(IndexError):
331 f.iscensored(3) 330 f.iscensored(3)
332 331
333 self.assertEqual(f.commonancestorsheads(node1, nullid), []) 332 self.assertEqual(f.commonancestorsheads(node1, f.nullid), [])
334 self.assertEqual(f.commonancestorsheads(node1, node0), [node0]) 333 self.assertEqual(f.commonancestorsheads(node1, node0), [node0])
335 self.assertEqual(f.commonancestorsheads(node1, node1), [node1]) 334 self.assertEqual(f.commonancestorsheads(node1, node1), [node1])
336 self.assertEqual(f.commonancestorsheads(node0, node1), [node0]) 335 self.assertEqual(f.commonancestorsheads(node0, node1), [node0])
337 self.assertEqual(f.commonancestorsheads(node1, node2), [node1]) 336 self.assertEqual(f.commonancestorsheads(node1, node2), [node1])
338 self.assertEqual(f.commonancestorsheads(node2, node1), [node1]) 337 self.assertEqual(f.commonancestorsheads(node2, node1), [node1])
362 361
363 def testmultipleheads(self): 362 def testmultipleheads(self):
364 f = self._makefilefn() 363 f = self._makefilefn()
365 364
366 with self._maketransactionfn() as tr: 365 with self._maketransactionfn() as tr:
367 node0 = f.add(b'0', None, tr, 0, nullid, nullid) 366 node0 = f.add(b'0', None, tr, 0, f.nullid, f.nullid)
368 node1 = f.add(b'1', None, tr, 1, node0, nullid) 367 node1 = f.add(b'1', None, tr, 1, node0, f.nullid)
369 node2 = f.add(b'2', None, tr, 2, node1, nullid) 368 node2 = f.add(b'2', None, tr, 2, node1, f.nullid)
370 node3 = f.add(b'3', None, tr, 3, node0, nullid) 369 node3 = f.add(b'3', None, tr, 3, node0, f.nullid)
371 node4 = f.add(b'4', None, tr, 4, node3, nullid) 370 node4 = f.add(b'4', None, tr, 4, node3, f.nullid)
372 node5 = f.add(b'5', None, tr, 5, node0, nullid) 371 node5 = f.add(b'5', None, tr, 5, node0, f.nullid)
373 372
374 self.assertEqual(len(f), 6) 373 self.assertEqual(len(f), 6)
375 374
376 self.assertEqual(list(f.descendants([0])), [1, 2, 3, 4, 5]) 375 self.assertEqual(list(f.descendants([0])), [1, 2, 3, 4, 5])
377 self.assertEqual(list(f.descendants([1])), [2]) 376 self.assertEqual(list(f.descendants([1])), [2])
425 continue 424 continue
426 425
427 with self.assertRaises(IndexError): 426 with self.assertRaises(IndexError):
428 f.size(i) 427 f.size(i)
429 428
430 self.assertEqual(f.revision(nullid), b'') 429 self.assertEqual(f.revision(f.nullid), b'')
431 self.assertEqual(f.rawdata(nullid), b'') 430 self.assertEqual(f.rawdata(f.nullid), b'')
432 431
433 with self.assertRaises(error.LookupError): 432 with self.assertRaises(error.LookupError):
434 f.revision(b'\x01' * 20) 433 f.revision(b'\x01' * 20)
435 434
436 self.assertEqual(f.read(nullid), b'') 435 self.assertEqual(f.read(f.nullid), b'')
437 436
438 with self.assertRaises(error.LookupError): 437 with self.assertRaises(error.LookupError):
439 f.read(b'\x01' * 20) 438 f.read(b'\x01' * 20)
440 439
441 self.assertFalse(f.renamed(nullid)) 440 self.assertFalse(f.renamed(f.nullid))
442 441
443 with self.assertRaises(error.LookupError): 442 with self.assertRaises(error.LookupError):
444 f.read(b'\x01' * 20) 443 f.read(b'\x01' * 20)
445 444
446 self.assertTrue(f.cmp(nullid, b'')) 445 self.assertTrue(f.cmp(f.nullid, b''))
447 self.assertTrue(f.cmp(nullid, b'foo')) 446 self.assertTrue(f.cmp(f.nullid, b'foo'))
448 447
449 with self.assertRaises(error.LookupError): 448 with self.assertRaises(error.LookupError):
450 f.cmp(b'\x01' * 20, b'irrelevant') 449 f.cmp(b'\x01' * 20, b'irrelevant')
451 450
452 # Emitting empty list is an empty generator. 451 # Emitting empty list is an empty generator.
453 gen = f.emitrevisions([]) 452 gen = f.emitrevisions([])
454 with self.assertRaises(StopIteration): 453 with self.assertRaises(StopIteration):
455 next(gen) 454 next(gen)
456 455
457 # Emitting null node yields nothing. 456 # Emitting null node yields nothing.
458 gen = f.emitrevisions([nullid]) 457 gen = f.emitrevisions([f.nullid])
459 with self.assertRaises(StopIteration): 458 with self.assertRaises(StopIteration):
460 next(gen) 459 next(gen)
461 460
462 # Requesting unknown node fails. 461 # Requesting unknown node fails.
463 with self.assertRaises(error.LookupError): 462 with self.assertRaises(error.LookupError):
466 def testsinglerevision(self): 465 def testsinglerevision(self):
467 fulltext = b'initial' 466 fulltext = b'initial'
468 467
469 f = self._makefilefn() 468 f = self._makefilefn()
470 with self._maketransactionfn() as tr: 469 with self._maketransactionfn() as tr:
471 node = f.add(fulltext, None, tr, 0, nullid, nullid) 470 node = f.add(fulltext, None, tr, 0, f.nullid, f.nullid)
472 471
473 self.assertEqual(f.storageinfo(), {}) 472 self.assertEqual(f.storageinfo(), {})
474 self.assertEqual( 473 self.assertEqual(
475 f.storageinfo(revisionscount=True, trackedsize=True), 474 f.storageinfo(revisionscount=True, trackedsize=True),
476 {b'revisionscount': 1, b'trackedsize': len(fulltext)}, 475 {b'revisionscount': 1, b'trackedsize': len(fulltext)},
494 # Emitting a single revision works. 493 # Emitting a single revision works.
495 gen = f.emitrevisions([node]) 494 gen = f.emitrevisions([node])
496 rev = next(gen) 495 rev = next(gen)
497 496
498 self.assertEqual(rev.node, node) 497 self.assertEqual(rev.node, node)
499 self.assertEqual(rev.p1node, nullid) 498 self.assertEqual(rev.p1node, f.nullid)
500 self.assertEqual(rev.p2node, nullid) 499 self.assertEqual(rev.p2node, f.nullid)
501 self.assertIsNone(rev.linknode) 500 self.assertIsNone(rev.linknode)
502 self.assertEqual(rev.basenode, nullid) 501 self.assertEqual(rev.basenode, f.nullid)
503 self.assertIsNone(rev.baserevisionsize) 502 self.assertIsNone(rev.baserevisionsize)
504 self.assertIsNone(rev.revision) 503 self.assertIsNone(rev.revision)
505 self.assertIsNone(rev.delta) 504 self.assertIsNone(rev.delta)
506 505
507 with self.assertRaises(StopIteration): 506 with self.assertRaises(StopIteration):
510 # Requesting revision data works. 509 # Requesting revision data works.
511 gen = f.emitrevisions([node], revisiondata=True) 510 gen = f.emitrevisions([node], revisiondata=True)
512 rev = next(gen) 511 rev = next(gen)
513 512
514 self.assertEqual(rev.node, node) 513 self.assertEqual(rev.node, node)
515 self.assertEqual(rev.p1node, nullid) 514 self.assertEqual(rev.p1node, f.nullid)
516 self.assertEqual(rev.p2node, nullid) 515 self.assertEqual(rev.p2node, f.nullid)
517 self.assertIsNone(rev.linknode) 516 self.assertIsNone(rev.linknode)
518 self.assertEqual(rev.basenode, nullid) 517 self.assertEqual(rev.basenode, f.nullid)
519 self.assertIsNone(rev.baserevisionsize) 518 self.assertIsNone(rev.baserevisionsize)
520 self.assertEqual(rev.revision, fulltext) 519 self.assertEqual(rev.revision, fulltext)
521 self.assertIsNone(rev.delta) 520 self.assertIsNone(rev.delta)
522 521
523 with self.assertRaises(StopIteration): 522 with self.assertRaises(StopIteration):
532 fulltext1 = fulltext0 + b'y' 531 fulltext1 = fulltext0 + b'y'
533 fulltext2 = b'y' + fulltext0 + b'z' 532 fulltext2 = b'y' + fulltext0 + b'z'
534 533
535 f = self._makefilefn() 534 f = self._makefilefn()
536 with self._maketransactionfn() as tr: 535 with self._maketransactionfn() as tr:
537 node0 = f.add(fulltext0, None, tr, 0, nullid, nullid) 536 node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid)
538 node1 = f.add(fulltext1, None, tr, 1, node0, nullid) 537 node1 = f.add(fulltext1, None, tr, 1, node0, f.nullid)
539 node2 = f.add(fulltext2, None, tr, 3, node1, nullid) 538 node2 = f.add(fulltext2, None, tr, 3, node1, f.nullid)
540 539
541 self.assertEqual(f.storageinfo(), {}) 540 self.assertEqual(f.storageinfo(), {})
542 self.assertEqual( 541 self.assertEqual(
543 f.storageinfo(revisionscount=True, trackedsize=True), 542 f.storageinfo(revisionscount=True, trackedsize=True),
544 { 543 {
594 gen = f.emitrevisions([node0, node1, node2], revisiondata=True) 593 gen = f.emitrevisions([node0, node1, node2], revisiondata=True)
595 594
596 rev = next(gen) 595 rev = next(gen)
597 596
598 self.assertEqual(rev.node, node0) 597 self.assertEqual(rev.node, node0)
599 self.assertEqual(rev.p1node, nullid) 598 self.assertEqual(rev.p1node, f.nullid)
600 self.assertEqual(rev.p2node, nullid) 599 self.assertEqual(rev.p2node, f.nullid)
601 self.assertIsNone(rev.linknode) 600 self.assertIsNone(rev.linknode)
602 self.assertEqual(rev.basenode, nullid) 601 self.assertEqual(rev.basenode, f.nullid)
603 self.assertIsNone(rev.baserevisionsize) 602 self.assertIsNone(rev.baserevisionsize)
604 self.assertEqual(rev.revision, fulltext0) 603 self.assertEqual(rev.revision, fulltext0)
605 self.assertIsNone(rev.delta) 604 self.assertIsNone(rev.delta)
606 605
607 rev = next(gen) 606 rev = next(gen)
608 607
609 self.assertEqual(rev.node, node1) 608 self.assertEqual(rev.node, node1)
610 self.assertEqual(rev.p1node, node0) 609 self.assertEqual(rev.p1node, node0)
611 self.assertEqual(rev.p2node, nullid) 610 self.assertEqual(rev.p2node, f.nullid)
612 self.assertIsNone(rev.linknode) 611 self.assertIsNone(rev.linknode)
613 self.assertEqual(rev.basenode, node0) 612 self.assertEqual(rev.basenode, node0)
614 self.assertIsNone(rev.baserevisionsize) 613 self.assertIsNone(rev.baserevisionsize)
615 self.assertIsNone(rev.revision) 614 self.assertIsNone(rev.revision)
616 self.assertEqual( 615 self.assertEqual(
620 619
621 rev = next(gen) 620 rev = next(gen)
622 621
623 self.assertEqual(rev.node, node2) 622 self.assertEqual(rev.node, node2)
624 self.assertEqual(rev.p1node, node1) 623 self.assertEqual(rev.p1node, node1)
625 self.assertEqual(rev.p2node, nullid) 624 self.assertEqual(rev.p2node, f.nullid)
626 self.assertIsNone(rev.linknode) 625 self.assertIsNone(rev.linknode)
627 self.assertEqual(rev.basenode, node1) 626 self.assertEqual(rev.basenode, node1)
628 self.assertIsNone(rev.baserevisionsize) 627 self.assertIsNone(rev.baserevisionsize)
629 self.assertIsNone(rev.revision) 628 self.assertIsNone(rev.revision)
630 self.assertEqual( 629 self.assertEqual(
639 gen = f.emitrevisions([node2, node1, node0], revisiondata=True) 638 gen = f.emitrevisions([node2, node1, node0], revisiondata=True)
640 639
641 rev = next(gen) 640 rev = next(gen)
642 641
643 self.assertEqual(rev.node, node0) 642 self.assertEqual(rev.node, node0)
644 self.assertEqual(rev.p1node, nullid) 643 self.assertEqual(rev.p1node, f.nullid)
645 self.assertEqual(rev.p2node, nullid) 644 self.assertEqual(rev.p2node, f.nullid)
646 self.assertIsNone(rev.linknode) 645 self.assertIsNone(rev.linknode)
647 self.assertEqual(rev.basenode, nullid) 646 self.assertEqual(rev.basenode, f.nullid)
648 self.assertIsNone(rev.baserevisionsize) 647 self.assertIsNone(rev.baserevisionsize)
649 self.assertEqual(rev.revision, fulltext0) 648 self.assertEqual(rev.revision, fulltext0)
650 self.assertIsNone(rev.delta) 649 self.assertIsNone(rev.delta)
651 650
652 rev = next(gen) 651 rev = next(gen)
653 652
654 self.assertEqual(rev.node, node1) 653 self.assertEqual(rev.node, node1)
655 self.assertEqual(rev.p1node, node0) 654 self.assertEqual(rev.p1node, node0)
656 self.assertEqual(rev.p2node, nullid) 655 self.assertEqual(rev.p2node, f.nullid)
657 self.assertIsNone(rev.linknode) 656 self.assertIsNone(rev.linknode)
658 self.assertEqual(rev.basenode, node0) 657 self.assertEqual(rev.basenode, node0)
659 self.assertIsNone(rev.baserevisionsize) 658 self.assertIsNone(rev.baserevisionsize)
660 self.assertIsNone(rev.revision) 659 self.assertIsNone(rev.revision)
661 self.assertEqual( 660 self.assertEqual(
665 664
666 rev = next(gen) 665 rev = next(gen)
667 666
668 self.assertEqual(rev.node, node2) 667 self.assertEqual(rev.node, node2)
669 self.assertEqual(rev.p1node, node1) 668 self.assertEqual(rev.p1node, node1)
670 self.assertEqual(rev.p2node, nullid) 669 self.assertEqual(rev.p2node, f.nullid)
671 self.assertIsNone(rev.linknode) 670 self.assertIsNone(rev.linknode)
672 self.assertEqual(rev.basenode, node1) 671 self.assertEqual(rev.basenode, node1)
673 self.assertIsNone(rev.baserevisionsize) 672 self.assertIsNone(rev.baserevisionsize)
674 self.assertIsNone(rev.revision) 673 self.assertIsNone(rev.revision)
675 self.assertEqual( 674 self.assertEqual(
698 ) 697 )
699 698
700 rev = next(gen) 699 rev = next(gen)
701 self.assertEqual(rev.node, node2) 700 self.assertEqual(rev.node, node2)
702 self.assertEqual(rev.p1node, node1) 701 self.assertEqual(rev.p1node, node1)
703 self.assertEqual(rev.p2node, nullid) 702 self.assertEqual(rev.p2node, f.nullid)
704 self.assertEqual(rev.basenode, nullid) 703 self.assertEqual(rev.basenode, f.nullid)
705 self.assertIsNone(rev.baserevisionsize) 704 self.assertIsNone(rev.baserevisionsize)
706 self.assertEqual(rev.revision, fulltext2) 705 self.assertEqual(rev.revision, fulltext2)
707 self.assertIsNone(rev.delta) 706 self.assertIsNone(rev.delta)
708 707
709 rev = next(gen) 708 rev = next(gen)
710 self.assertEqual(rev.node, node0) 709 self.assertEqual(rev.node, node0)
711 self.assertEqual(rev.p1node, nullid) 710 self.assertEqual(rev.p1node, f.nullid)
712 self.assertEqual(rev.p2node, nullid) 711 self.assertEqual(rev.p2node, f.nullid)
713 # Delta behavior is storage dependent, so we can't easily test it. 712 # Delta behavior is storage dependent, so we can't easily test it.
714 713
715 with self.assertRaises(StopIteration): 714 with self.assertRaises(StopIteration):
716 next(gen) 715 next(gen)
717 716
720 gen = f.emitrevisions({node2, node1}, revisiondata=True) 719 gen = f.emitrevisions({node2, node1}, revisiondata=True)
721 720
722 rev = next(gen) 721 rev = next(gen)
723 self.assertEqual(rev.node, node1) 722 self.assertEqual(rev.node, node1)
724 self.assertEqual(rev.p1node, node0) 723 self.assertEqual(rev.p1node, node0)
725 self.assertEqual(rev.p2node, nullid) 724 self.assertEqual(rev.p2node, f.nullid)
726 self.assertEqual(rev.basenode, nullid) 725 self.assertEqual(rev.basenode, f.nullid)
727 self.assertIsNone(rev.baserevisionsize) 726 self.assertIsNone(rev.baserevisionsize)
728 self.assertEqual(rev.revision, fulltext1) 727 self.assertEqual(rev.revision, fulltext1)
729 self.assertIsNone(rev.delta) 728 self.assertIsNone(rev.delta)
730 729
731 rev = next(gen) 730 rev = next(gen)
732 self.assertEqual(rev.node, node2) 731 self.assertEqual(rev.node, node2)
733 self.assertEqual(rev.p1node, node1) 732 self.assertEqual(rev.p1node, node1)
734 self.assertEqual(rev.p2node, nullid) 733 self.assertEqual(rev.p2node, f.nullid)
735 self.assertEqual(rev.basenode, node1) 734 self.assertEqual(rev.basenode, node1)
736 self.assertIsNone(rev.baserevisionsize) 735 self.assertIsNone(rev.baserevisionsize)
737 self.assertIsNone(rev.revision) 736 self.assertIsNone(rev.revision)
738 self.assertEqual( 737 self.assertEqual(
739 rev.delta, 738 rev.delta,
749 ) 748 )
750 749
751 rev = next(gen) 750 rev = next(gen)
752 self.assertEqual(rev.node, node1) 751 self.assertEqual(rev.node, node1)
753 self.assertEqual(rev.p1node, node0) 752 self.assertEqual(rev.p1node, node0)
754 self.assertEqual(rev.p2node, nullid) 753 self.assertEqual(rev.p2node, f.nullid)
755 self.assertEqual(rev.basenode, node0) 754 self.assertEqual(rev.basenode, node0)
756 self.assertIsNone(rev.baserevisionsize) 755 self.assertIsNone(rev.baserevisionsize)
757 self.assertIsNone(rev.revision) 756 self.assertIsNone(rev.revision)
758 self.assertEqual( 757 self.assertEqual(
759 rev.delta, 758 rev.delta,
766 [node0], revisiondata=True, deltamode=repository.CG_DELTAMODE_PREV 765 [node0], revisiondata=True, deltamode=repository.CG_DELTAMODE_PREV
767 ) 766 )
768 767
769 rev = next(gen) 768 rev = next(gen)
770 self.assertEqual(rev.node, node0) 769 self.assertEqual(rev.node, node0)
771 self.assertEqual(rev.p1node, nullid) 770 self.assertEqual(rev.p1node, f.nullid)
772 self.assertEqual(rev.p2node, nullid) 771 self.assertEqual(rev.p2node, f.nullid)
773 self.assertEqual(rev.basenode, nullid) 772 self.assertEqual(rev.basenode, f.nullid)
774 self.assertIsNone(rev.baserevisionsize) 773 self.assertIsNone(rev.baserevisionsize)
775 self.assertIsNone(rev.revision) 774 self.assertIsNone(rev.revision)
776 self.assertEqual( 775 self.assertEqual(
777 rev.delta, 776 rev.delta,
778 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' + fulltext0, 777 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' + fulltext0,
787 deltamode=repository.CG_DELTAMODE_PREV, 786 deltamode=repository.CG_DELTAMODE_PREV,
788 ) 787 )
789 788
790 rev = next(gen) 789 rev = next(gen)
791 self.assertEqual(rev.node, node0) 790 self.assertEqual(rev.node, node0)
792 self.assertEqual(rev.p1node, nullid) 791 self.assertEqual(rev.p1node, f.nullid)
793 self.assertEqual(rev.p2node, nullid) 792 self.assertEqual(rev.p2node, f.nullid)
794 self.assertEqual(rev.basenode, nullid) 793 self.assertEqual(rev.basenode, f.nullid)
795 self.assertIsNone(rev.baserevisionsize) 794 self.assertIsNone(rev.baserevisionsize)
796 self.assertIsNone(rev.revision) 795 self.assertIsNone(rev.revision)
797 self.assertEqual( 796 self.assertEqual(
798 rev.delta, 797 rev.delta,
799 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' + fulltext0, 798 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' + fulltext0,
800 ) 799 )
801 800
802 rev = next(gen) 801 rev = next(gen)
803 self.assertEqual(rev.node, node2) 802 self.assertEqual(rev.node, node2)
804 self.assertEqual(rev.p1node, node1) 803 self.assertEqual(rev.p1node, node1)
805 self.assertEqual(rev.p2node, nullid) 804 self.assertEqual(rev.p2node, f.nullid)
806 self.assertEqual(rev.basenode, node0) 805 self.assertEqual(rev.basenode, node0)
807 806
808 with self.assertRaises(StopIteration): 807 with self.assertRaises(StopIteration):
809 next(gen) 808 next(gen)
810 809
839 ] 838 ]
840 ) 839 )
841 840
842 f = self._makefilefn() 841 f = self._makefilefn()
843 with self._maketransactionfn() as tr: 842 with self._maketransactionfn() as tr:
844 node0 = f.add(fulltext0, None, tr, 0, nullid, nullid) 843 node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid)
845 node1 = f.add(fulltext1, meta1, tr, 1, node0, nullid) 844 node1 = f.add(fulltext1, meta1, tr, 1, node0, f.nullid)
846 node2 = f.add(fulltext2, meta2, tr, 2, nullid, nullid) 845 node2 = f.add(fulltext2, meta2, tr, 2, f.nullid, f.nullid)
847 846
848 # Metadata header isn't recognized when parent isn't nullid. 847 # Metadata header isn't recognized when parent isn't f.nullid.
849 self.assertEqual(f.size(1), len(stored1)) 848 self.assertEqual(f.size(1), len(stored1))
850 self.assertEqual(f.size(2), len(fulltext2)) 849 self.assertEqual(f.size(2), len(fulltext2))
851 850
852 self.assertEqual(f.revision(node1), stored1) 851 self.assertEqual(f.revision(node1), stored1)
853 self.assertEqual(f.rawdata(node1), stored1) 852 self.assertEqual(f.rawdata(node1), stored1)
884 ] 883 ]
885 ) 884 )
886 885
887 f = self._makefilefn() 886 f = self._makefilefn()
888 with self._maketransactionfn() as tr: 887 with self._maketransactionfn() as tr:
889 node0 = f.add(fulltext0, {}, tr, 0, nullid, nullid) 888 node0 = f.add(fulltext0, {}, tr, 0, f.nullid, f.nullid)
890 node1 = f.add(fulltext1, meta1, tr, 1, nullid, nullid) 889 node1 = f.add(fulltext1, meta1, tr, 1, f.nullid, f.nullid)
891 890
892 # TODO this is buggy. 891 # TODO this is buggy.
893 self.assertEqual(f.size(0), len(fulltext0) + 4) 892 self.assertEqual(f.size(0), len(fulltext0) + 4)
894 893
895 self.assertEqual(f.size(1), len(fulltext1)) 894 self.assertEqual(f.size(1), len(fulltext1))
914 913
915 fulltext0 = b'foo\n' * 30 914 fulltext0 = b'foo\n' * 30
916 fulltext1 = fulltext0 + b'bar\n' 915 fulltext1 = fulltext0 + b'bar\n'
917 916
918 with self._maketransactionfn() as tr: 917 with self._maketransactionfn() as tr:
919 node0 = f.add(fulltext0, None, tr, 0, nullid, nullid) 918 node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid)
920 node1 = b'\xaa' * 20 919 node1 = b'\xaa' * 20
921 920
922 self._addrawrevisionfn( 921 self._addrawrevisionfn(
923 f, tr, node1, node0, nullid, 1, rawtext=fulltext1 922 f, tr, node1, node0, f.nullid, 1, rawtext=fulltext1
924 ) 923 )
925 924
926 self.assertEqual(len(f), 2) 925 self.assertEqual(len(f), 2)
927 self.assertEqual(f.parents(node1), (node0, nullid)) 926 self.assertEqual(f.parents(node1), (node0, f.nullid))
928 927
929 # revision() raises since it performs hash verification. 928 # revision() raises since it performs hash verification.
930 with self.assertRaises(error.StorageError): 929 with self.assertRaises(error.StorageError):
931 f.revision(node1) 930 f.revision(node1)
932 931
949 948
950 fulltext0 = b'foo\n' * 30 949 fulltext0 = b'foo\n' * 30
951 fulltext1 = fulltext0 + b'bar\n' 950 fulltext1 = fulltext0 + b'bar\n'
952 951
953 with self._maketransactionfn() as tr: 952 with self._maketransactionfn() as tr:
954 node0 = f.add(fulltext0, None, tr, 0, nullid, nullid) 953 node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid)
955 node1 = b'\xaa' * 20 954 node1 = b'\xaa' * 20
956 955
957 self._addrawrevisionfn( 956 self._addrawrevisionfn(
958 f, tr, node1, node0, nullid, 1, rawtext=fulltext1 957 f, tr, node1, node0, f.nullid, 1, rawtext=fulltext1
959 ) 958 )
960 959
961 with self.assertRaises(error.StorageError): 960 with self.assertRaises(error.StorageError):
962 f.rawdata(node1) 961 f.rawdata(node1)
963 962
971 970
972 fulltext0 = b'foo\n' * 30 971 fulltext0 = b'foo\n' * 30
973 fulltext1 = fulltext0 + b'bar\n' 972 fulltext1 = fulltext0 + b'bar\n'
974 973
975 with self._maketransactionfn() as tr: 974 with self._maketransactionfn() as tr:
976 node0 = f.add(fulltext0, None, tr, 0, nullid, nullid) 975 node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid)
977 node1 = b'\xaa' * 20 976 node1 = b'\xaa' * 20
978 977
979 self._addrawrevisionfn( 978 self._addrawrevisionfn(
980 f, tr, node1, node0, nullid, 1, rawtext=fulltext1 979 f, tr, node1, node0, f.nullid, 1, rawtext=fulltext1
981 ) 980 )
982 981
983 with self.assertRaises(error.StorageError): 982 with self.assertRaises(error.StorageError):
984 f.read(node1) 983 f.read(node1)
985 984
992 fulltext0 = b'foo\n' * 31 991 fulltext0 = b'foo\n' * 31
993 fulltext1 = fulltext0 + b'bar\n' 992 fulltext1 = fulltext0 + b'bar\n'
994 fulltext2 = fulltext1 + b'baz\n' 993 fulltext2 = fulltext1 + b'baz\n'
995 994
996 with self._maketransactionfn() as tr: 995 with self._maketransactionfn() as tr:
997 node0 = f.add(fulltext0, None, tr, 0, nullid, nullid) 996 node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid)
998 node1 = b'\xaa' * 20 997 node1 = b'\xaa' * 20
999 998
1000 self._addrawrevisionfn( 999 self._addrawrevisionfn(
1001 f, tr, node1, node0, nullid, 1, rawtext=fulltext1 1000 f, tr, node1, node0, f.nullid, 1, rawtext=fulltext1
1002 ) 1001 )
1003 1002
1004 with self.assertRaises(error.StorageError): 1003 with self.assertRaises(error.StorageError):
1005 f.read(node1) 1004 f.read(node1)
1006 1005
1007 node2 = storageutil.hashrevisionsha1(fulltext2, node1, nullid) 1006 node2 = storageutil.hashrevisionsha1(fulltext2, node1, f.nullid)
1008 1007
1009 with self._maketransactionfn() as tr: 1008 with self._maketransactionfn() as tr:
1010 delta = mdiff.textdiff(fulltext1, fulltext2) 1009 delta = mdiff.textdiff(fulltext1, fulltext2)
1011 self._addrawrevisionfn( 1010 self._addrawrevisionfn(
1012 f, tr, node2, node1, nullid, 2, delta=(1, delta) 1011 f, tr, node2, node1, f.nullid, 2, delta=(1, delta)
1013 ) 1012 )
1014 1013
1015 self.assertEqual(len(f), 3) 1014 self.assertEqual(len(f), 3)
1016 1015
1017 # Assuming a delta is stored, we shouldn't need to validate node1 in 1016 # Assuming a delta is stored, we shouldn't need to validate node1 in
1027 }, 1026 },
1028 b'', 1027 b'',
1029 ) 1028 )
1030 1029
1031 with self._maketransactionfn() as tr: 1030 with self._maketransactionfn() as tr:
1032 node0 = f.add(b'foo', None, tr, 0, nullid, nullid) 1031 node0 = f.add(b'foo', None, tr, 0, f.nullid, f.nullid)
1033 1032
1034 # The node value doesn't matter since we can't verify it. 1033 # The node value doesn't matter since we can't verify it.
1035 node1 = b'\xbb' * 20 1034 node1 = b'\xbb' * 20
1036 1035
1037 self._addrawrevisionfn( 1036 self._addrawrevisionfn(
1038 f, tr, node1, node0, nullid, 1, stored1, censored=True 1037 f, tr, node1, node0, f.nullid, 1, stored1, censored=True
1039 ) 1038 )
1040 1039
1041 self.assertTrue(f.iscensored(1)) 1040 self.assertTrue(f.iscensored(1))
1042 1041
1043 with self.assertRaises(error.CensoredNodeError): 1042 with self.assertRaises(error.CensoredNodeError):
1061 }, 1060 },
1062 b'', 1061 b'',
1063 ) 1062 )
1064 1063
1065 with self._maketransactionfn() as tr: 1064 with self._maketransactionfn() as tr:
1066 node0 = f.add(b'foo', None, tr, 0, nullid, nullid) 1065 node0 = f.add(b'foo', None, tr, 0, f.nullid, f.nullid)
1067 1066
1068 # The node value doesn't matter since we can't verify it. 1067 # The node value doesn't matter since we can't verify it.
1069 node1 = b'\xbb' * 20 1068 node1 = b'\xbb' * 20
1070 1069
1071 self._addrawrevisionfn( 1070 self._addrawrevisionfn(
1072 f, tr, node1, node0, nullid, 1, stored1, censored=True 1071 f, tr, node1, node0, f.nullid, 1, stored1, censored=True
1073 ) 1072 )
1074 1073
1075 with self.assertRaises(error.CensoredNodeError): 1074 with self.assertRaises(error.CensoredNodeError):
1076 f.rawdata(1) 1075 f.rawdata(1)
1077 1076
1086 """ 1085 """
1087 1086
1088 def testaddnoop(self): 1087 def testaddnoop(self):
1089 f = self._makefilefn() 1088 f = self._makefilefn()
1090 with self._maketransactionfn() as tr: 1089 with self._maketransactionfn() as tr:
1091 node0 = f.add(b'foo', None, tr, 0, nullid, nullid) 1090 node0 = f.add(b'foo', None, tr, 0, f.nullid, f.nullid)
1092 node1 = f.add(b'foo', None, tr, 0, nullid, nullid) 1091 node1 = f.add(b'foo', None, tr, 0, f.nullid, f.nullid)
1093 # Varying by linkrev shouldn't impact hash. 1092 # Varying by linkrev shouldn't impact hash.
1094 node2 = f.add(b'foo', None, tr, 1, nullid, nullid) 1093 node2 = f.add(b'foo', None, tr, 1, f.nullid, f.nullid)
1095 1094
1096 self.assertEqual(node1, node0) 1095 self.assertEqual(node1, node0)
1097 self.assertEqual(node2, node0) 1096 self.assertEqual(node2, node0)
1098 self.assertEqual(len(f), 1) 1097 self.assertEqual(len(f), 1)
1099 1098
1100 def testaddrevisionbadnode(self): 1099 def testaddrevisionbadnode(self):
1101 f = self._makefilefn() 1100 f = self._makefilefn()
1102 with self._maketransactionfn() as tr: 1101 with self._maketransactionfn() as tr:
1103 # Adding a revision with bad node value fails. 1102 # Adding a revision with bad node value fails.
1104 with self.assertRaises(error.StorageError): 1103 with self.assertRaises(error.StorageError):
1105 f.addrevision(b'foo', tr, 0, nullid, nullid, node=b'\x01' * 20) 1104 f.addrevision(
1105 b'foo', tr, 0, f.nullid, f.nullid, node=b'\x01' * 20
1106 )
1106 1107
1107 def testaddrevisionunknownflag(self): 1108 def testaddrevisionunknownflag(self):
1108 f = self._makefilefn() 1109 f = self._makefilefn()
1109 with self._maketransactionfn() as tr: 1110 with self._maketransactionfn() as tr:
1110 for i in range(15, 0, -1): 1111 for i in range(15, 0, -1):
1111 if (1 << i) & ~repository.REVISION_FLAGS_KNOWN: 1112 if (1 << i) & ~repository.REVISION_FLAGS_KNOWN:
1112 flags = 1 << i 1113 flags = 1 << i
1113 break 1114 break
1114 1115
1115 with self.assertRaises(error.StorageError): 1116 with self.assertRaises(error.StorageError):
1116 f.addrevision(b'foo', tr, 0, nullid, nullid, flags=flags) 1117 f.addrevision(b'foo', tr, 0, f.nullid, f.nullid, flags=flags)
1117 1118
1118 def testaddgroupsimple(self): 1119 def testaddgroupsimple(self):
1119 f = self._makefilefn() 1120 f = self._makefilefn()
1120 1121
1121 callbackargs = [] 1122 callbackargs = []
1151 1152
1152 fulltext0 = b'foo' 1153 fulltext0 = b'foo'
1153 delta0 = mdiff.trivialdiffheader(len(fulltext0)) + fulltext0 1154 delta0 = mdiff.trivialdiffheader(len(fulltext0)) + fulltext0
1154 1155
1155 with self._maketransactionfn() as tr: 1156 with self._maketransactionfn() as tr:
1156 node0 = f.add(fulltext0, None, tr, 0, nullid, nullid) 1157 node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid)
1157 1158
1158 f = self._makefilefn() 1159 f = self._makefilefn()
1159 1160
1160 deltas = [ 1161 deltas = [
1161 (node0, nullid, nullid, nullid, nullid, delta0, 0, {}), 1162 (node0, f.nullid, f.nullid, f.nullid, f.nullid, delta0, 0, {}),
1162 ] 1163 ]
1163 1164
1164 with self._maketransactionfn() as tr: 1165 with self._maketransactionfn() as tr:
1165 nodes = [] 1166 nodes = []
1166 1167
1205 ] 1206 ]
1206 1207
1207 nodes = [] 1208 nodes = []
1208 with self._maketransactionfn() as tr: 1209 with self._maketransactionfn() as tr:
1209 for fulltext in fulltexts: 1210 for fulltext in fulltexts:
1210 nodes.append(f.add(fulltext, None, tr, 0, nullid, nullid)) 1211 nodes.append(f.add(fulltext, None, tr, 0, f.nullid, f.nullid))
1211 1212
1212 f = self._makefilefn() 1213 f = self._makefilefn()
1213 deltas = [] 1214 deltas = []
1214 for i, fulltext in enumerate(fulltexts): 1215 for i, fulltext in enumerate(fulltexts):
1215 delta = mdiff.trivialdiffheader(len(fulltext)) + fulltext 1216 delta = mdiff.trivialdiffheader(len(fulltext)) + fulltext
1216 1217
1217 deltas.append( 1218 deltas.append(
1218 (nodes[i], nullid, nullid, nullid, nullid, delta, 0, {}) 1219 (nodes[i], f.nullid, f.nullid, f.nullid, f.nullid, delta, 0, {})
1219 ) 1220 )
1220 1221
1221 with self._maketransactionfn() as tr: 1222 with self._maketransactionfn() as tr:
1222 newnodes = [] 1223 newnodes = []
1223 1224
1252 }, 1253 },
1253 b'', 1254 b'',
1254 ) 1255 )
1255 1256
1256 with self._maketransactionfn() as tr: 1257 with self._maketransactionfn() as tr:
1257 node0 = f.add(b'foo\n' * 30, None, tr, 0, nullid, nullid) 1258 node0 = f.add(b'foo\n' * 30, None, tr, 0, f.nullid, f.nullid)
1258 1259
1259 # The node value doesn't matter since we can't verify it. 1260 # The node value doesn't matter since we can't verify it.
1260 node1 = b'\xbb' * 20 1261 node1 = b'\xbb' * 20
1261 1262
1262 self._addrawrevisionfn( 1263 self._addrawrevisionfn(
1263 f, tr, node1, node0, nullid, 1, stored1, censored=True 1264 f, tr, node1, node0, f.nullid, 1, stored1, censored=True
1264 ) 1265 )
1265 1266
1266 delta = mdiff.textdiff(b'bar\n' * 30, (b'bar\n' * 30) + b'baz\n') 1267 delta = mdiff.textdiff(b'bar\n' * 30, (b'bar\n' * 30) + b'baz\n')
1267 deltas = [ 1268 deltas = [
1268 (b'\xcc' * 20, node1, nullid, b'\x01' * 20, node1, delta, 0, {}) 1269 (b'\xcc' * 20, node1, f.nullid, b'\x01' * 20, node1, delta, 0, {})
1269 ] 1270 ]
1270 1271
1271 with self._maketransactionfn() as tr: 1272 with self._maketransactionfn() as tr:
1272 with self.assertRaises(error.CensoredBaseError): 1273 with self.assertRaises(error.CensoredBaseError):
1273 f.addgroup(deltas, lambda x: 0, tr) 1274 f.addgroup(deltas, lambda x: 0, tr)
1274 1275
1275 def testcensorrevisionbasic(self): 1276 def testcensorrevisionbasic(self):
1276 f = self._makefilefn() 1277 f = self._makefilefn()
1277 1278
1278 with self._maketransactionfn() as tr: 1279 with self._maketransactionfn() as tr:
1279 node0 = f.add(b'foo\n' * 30, None, tr, 0, nullid, nullid) 1280 node0 = f.add(b'foo\n' * 30, None, tr, 0, f.nullid, f.nullid)
1280 node1 = f.add(b'foo\n' * 31, None, tr, 1, node0, nullid) 1281 node1 = f.add(b'foo\n' * 31, None, tr, 1, node0, f.nullid)
1281 node2 = f.add(b'foo\n' * 32, None, tr, 2, node1, nullid) 1282 node2 = f.add(b'foo\n' * 32, None, tr, 2, node1, f.nullid)
1282 1283
1283 with self._maketransactionfn() as tr: 1284 with self._maketransactionfn() as tr:
1284 f.censorrevision(tr, node1) 1285 f.censorrevision(tr, node1)
1285 1286
1286 self.assertEqual(len(f), 3) 1287 self.assertEqual(len(f), 3)
1296 # N revisions where none have parents. 1297 # N revisions where none have parents.
1297 f = self._makefilefn() 1298 f = self._makefilefn()
1298 1299
1299 with self._maketransactionfn() as tr: 1300 with self._maketransactionfn() as tr:
1300 for rev in range(10): 1301 for rev in range(10):
1301 f.add(b'%d' % rev, None, tr, rev, nullid, nullid) 1302 f.add(b'%d' % rev, None, tr, rev, f.nullid, f.nullid)
1302 1303
1303 for rev in range(10): 1304 for rev in range(10):
1304 self.assertEqual(f.getstrippoint(rev), (rev, set())) 1305 self.assertEqual(f.getstrippoint(rev), (rev, set()))
1305 1306
1306 def testgetstrippointlinear(self): 1307 def testgetstrippointlinear(self):
1307 # N revisions in a linear chain. 1308 # N revisions in a linear chain.
1308 f = self._makefilefn() 1309 f = self._makefilefn()
1309 1310
1310 with self._maketransactionfn() as tr: 1311 with self._maketransactionfn() as tr:
1311 p1 = nullid 1312 p1 = f.nullid
1312 1313
1313 for rev in range(10): 1314 for rev in range(10):
1314 f.add(b'%d' % rev, None, tr, rev, p1, nullid) 1315 f.add(b'%d' % rev, None, tr, rev, p1, f.nullid)
1315 1316
1316 for rev in range(10): 1317 for rev in range(10):
1317 self.assertEqual(f.getstrippoint(rev), (rev, set())) 1318 self.assertEqual(f.getstrippoint(rev), (rev, set()))
1318 1319
1319 def testgetstrippointmultipleheads(self): 1320 def testgetstrippointmultipleheads(self):
1320 f = self._makefilefn() 1321 f = self._makefilefn()
1321 1322
1322 with self._maketransactionfn() as tr: 1323 with self._maketransactionfn() as tr:
1323 node0 = f.add(b'0', None, tr, 0, nullid, nullid) 1324 node0 = f.add(b'0', None, tr, 0, f.nullid, f.nullid)
1324 node1 = f.add(b'1', None, tr, 1, node0, nullid) 1325 node1 = f.add(b'1', None, tr, 1, node0, f.nullid)
1325 f.add(b'2', None, tr, 2, node1, nullid) 1326 f.add(b'2', None, tr, 2, node1, f.nullid)
1326 f.add(b'3', None, tr, 3, node0, nullid) 1327 f.add(b'3', None, tr, 3, node0, f.nullid)
1327 f.add(b'4', None, tr, 4, node0, nullid) 1328 f.add(b'4', None, tr, 4, node0, f.nullid)
1328 1329
1329 for rev in range(5): 1330 for rev in range(5):
1330 self.assertEqual(f.getstrippoint(rev), (rev, set())) 1331 self.assertEqual(f.getstrippoint(rev), (rev, set()))
1331 1332
1332 def testgetstrippointearlierlinkrevs(self): 1333 def testgetstrippointearlierlinkrevs(self):
1333 f = self._makefilefn() 1334 f = self._makefilefn()
1334 1335
1335 with self._maketransactionfn() as tr: 1336 with self._maketransactionfn() as tr:
1336 node0 = f.add(b'0', None, tr, 0, nullid, nullid) 1337 node0 = f.add(b'0', None, tr, 0, f.nullid, f.nullid)
1337 f.add(b'1', None, tr, 10, node0, nullid) 1338 f.add(b'1', None, tr, 10, node0, f.nullid)
1338 f.add(b'2', None, tr, 5, node0, nullid) 1339 f.add(b'2', None, tr, 5, node0, f.nullid)
1339 1340
1340 self.assertEqual(f.getstrippoint(0), (0, set())) 1341 self.assertEqual(f.getstrippoint(0), (0, set()))
1341 self.assertEqual(f.getstrippoint(1), (1, set())) 1342 self.assertEqual(f.getstrippoint(1), (1, set()))
1342 self.assertEqual(f.getstrippoint(2), (1, set())) 1343 self.assertEqual(f.getstrippoint(2), (1, set()))
1343 self.assertEqual(f.getstrippoint(3), (1, set())) 1344 self.assertEqual(f.getstrippoint(3), (1, set()))
1360 1361
1361 def teststripall(self): 1362 def teststripall(self):
1362 f = self._makefilefn() 1363 f = self._makefilefn()
1363 1364
1364 with self._maketransactionfn() as tr: 1365 with self._maketransactionfn() as tr:
1365 p1 = nullid 1366 p1 = f.nullid
1366 for rev in range(10): 1367 for rev in range(10):
1367 p1 = f.add(b'%d' % rev, None, tr, rev, p1, nullid) 1368 p1 = f.add(b'%d' % rev, None, tr, rev, p1, f.nullid)
1368 1369
1369 self.assertEqual(len(f), 10) 1370 self.assertEqual(len(f), 10)
1370 1371
1371 with self._maketransactionfn() as tr: 1372 with self._maketransactionfn() as tr:
1372 f.strip(0, tr) 1373 f.strip(0, tr)
1375 1376
1376 def teststrippartial(self): 1377 def teststrippartial(self):
1377 f = self._makefilefn() 1378 f = self._makefilefn()
1378 1379
1379 with self._maketransactionfn() as tr: 1380 with self._maketransactionfn() as tr:
1380 f.add(b'0', None, tr, 0, nullid, nullid) 1381 f.add(b'0', None, tr, 0, f.nullid, f.nullid)
1381 node1 = f.add(b'1', None, tr, 5, nullid, nullid) 1382 node1 = f.add(b'1', None, tr, 5, f.nullid, f.nullid)
1382 node2 = f.add(b'2', None, tr, 10, nullid, nullid) 1383 node2 = f.add(b'2', None, tr, 10, f.nullid, f.nullid)
1383 1384
1384 self.assertEqual(len(f), 3) 1385 self.assertEqual(len(f), 3)
1385 1386
1386 with self._maketransactionfn() as tr: 1387 with self._maketransactionfn() as tr:
1387 f.strip(11, tr) 1388 f.strip(11, tr)