503         # Emitting empty list is an empty generator.

   504         gen = f.emitrevisions([])

   505         with self.assertRaises(StopIteration):

   506             next(gen)

   507 

   508         # Emitting null node yields nothing.

   509         gen = f.emitrevisions([nullid])

   510         with self.assertRaises(StopIteration):

   511             next(gen)

   512 

   513         # Requesting unknown node fails.

   514         with self.assertRaises(error.LookupError):

   515             list(f.emitrevisions([b'\x01' * 20]))

   516 

   582 

   583         # Emitting a single revision works.

   584         gen = f.emitrevisions([node])

   585         rev = next(gen)

   586 

   587         self.assertEqual(rev.node, node)

   588         self.assertEqual(rev.p1node, nullid)

   589         self.assertEqual(rev.p2node, nullid)

   590         self.assertIsNone(rev.linknode)

   591         self.assertEqual(rev.basenode, nullid)

   592         self.assertIsNone(rev.baserevisionsize)

   593         self.assertIsNone(rev.revision)

   594         self.assertIsNone(rev.delta)

   595 

   596         with self.assertRaises(StopIteration):

   597             next(gen)

   598 

   599         # Requesting revision data works.

   600         gen = f.emitrevisions([node], revisiondata=True)

   601         rev = next(gen)

   602 

   603         self.assertEqual(rev.node, node)

   604         self.assertEqual(rev.p1node, nullid)

   605         self.assertEqual(rev.p2node, nullid)

   606         self.assertIsNone(rev.linknode)

   607         self.assertEqual(rev.basenode, nullid)

   608         self.assertIsNone(rev.baserevisionsize)

   609         self.assertEqual(rev.revision, fulltext)

   610         self.assertIsNone(rev.delta)

   611 

   612         with self.assertRaises(StopIteration):

   613             next(gen)

   614 

   615         # Emitting an unknown node after a known revision results in error.

   616         with self.assertRaises(error.LookupError):

   617             list(f.emitrevisions([node, b'\x01' * 20]))

   750         # Nodes should be emitted in order.

   751         gen = f.emitrevisions([node0, node1, node2], revisiondata=True)

   752 

   753         rev = next(gen)

   754 

   755         self.assertEqual(rev.node, node0)

   756         self.assertEqual(rev.p1node, nullid)

   757         self.assertEqual(rev.p2node, nullid)

   758         self.assertIsNone(rev.linknode)

   759         self.assertEqual(rev.basenode, nullid)

   760         self.assertIsNone(rev.baserevisionsize)

   761         self.assertEqual(rev.revision, fulltext0)

   762         self.assertIsNone(rev.delta)

   763 

   764         rev = next(gen)

   765 

   766         self.assertEqual(rev.node, node1)

   767         self.assertEqual(rev.p1node, node0)

   768         self.assertEqual(rev.p2node, nullid)

   769         self.assertIsNone(rev.linknode)

   770         self.assertEqual(rev.basenode, node0)

   771         self.assertIsNone(rev.baserevisionsize)

   772         self.assertIsNone(rev.revision)

   773         self.assertEqual(rev.delta,

   774                          b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' +

   775                          fulltext1)

   776 

   777         rev = next(gen)

   778 

   779         self.assertEqual(rev.node, node2)

   780         self.assertEqual(rev.p1node, node1)

   781         self.assertEqual(rev.p2node, nullid)

   782         self.assertIsNone(rev.linknode)

   783         self.assertEqual(rev.basenode, node1)

   784         self.assertIsNone(rev.baserevisionsize)

   785         self.assertIsNone(rev.revision)

   786         self.assertEqual(rev.delta,

   787                          b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' +

   788                          fulltext2)

   789 

   790         with self.assertRaises(StopIteration):

   791             next(gen)

   792 

   793         # Request not in DAG order is reordered to be in DAG order.

   794         gen = f.emitrevisions([node2, node1, node0], revisiondata=True)

   795 

   796         rev = next(gen)

   797 

   798         self.assertEqual(rev.node, node0)

   799         self.assertEqual(rev.p1node, nullid)

   800         self.assertEqual(rev.p2node, nullid)

   801         self.assertIsNone(rev.linknode)

   802         self.assertEqual(rev.basenode, nullid)

   803         self.assertIsNone(rev.baserevisionsize)

   804         self.assertEqual(rev.revision, fulltext0)

   805         self.assertIsNone(rev.delta)

   806 

   807         rev = next(gen)

   808 

   809         self.assertEqual(rev.node, node1)

   810         self.assertEqual(rev.p1node, node0)

   811         self.assertEqual(rev.p2node, nullid)

   812         self.assertIsNone(rev.linknode)

   813         self.assertEqual(rev.basenode, node0)

   814         self.assertIsNone(rev.baserevisionsize)

   815         self.assertIsNone(rev.revision)

   816         self.assertEqual(rev.delta,

   817                          b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' +

   818                          fulltext1)

   819 

   820         rev = next(gen)

   821 

   822         self.assertEqual(rev.node, node2)

   823         self.assertEqual(rev.p1node, node1)

   824         self.assertEqual(rev.p2node, nullid)

   825         self.assertIsNone(rev.linknode)

   826         self.assertEqual(rev.basenode, node1)

   827         self.assertIsNone(rev.baserevisionsize)

   828         self.assertIsNone(rev.revision)

   829         self.assertEqual(rev.delta,

   830                          b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' +

   831                          fulltext2)

   832 

   833         with self.assertRaises(StopIteration):

   834             next(gen)

   835 

   836         # Unrecognized nodesorder value raises ProgrammingError.

   837         with self.assertRaises(error.ProgrammingError):

   838             list(f.emitrevisions([], nodesorder='bad'))

   839 

   840         # nodesorder=storage is recognized. But we can't test it thoroughly

   841         # because behavior is storage-dependent.

   842         res = list(f.emitrevisions([node2, node1, node0],

   843                                          nodesorder='storage'))

   844         self.assertEqual(len(res), 3)

   845         self.assertEqual({o.node for o in res}, {node0, node1, node2})

   846 

   847         # nodesorder=nodes forces the order.

   848         gen = f.emitrevisions([node2, node0], nodesorder='nodes',

   849                               revisiondata=True)

   850 

   851         rev = next(gen)

   852         self.assertEqual(rev.node, node2)

   853         self.assertEqual(rev.p1node, node1)

   854         self.assertEqual(rev.p2node, nullid)

   855         self.assertEqual(rev.basenode, nullid)

   856         self.assertIsNone(rev.baserevisionsize)

   857         self.assertEqual(rev.revision, fulltext2)

   858         self.assertIsNone(rev.delta)

   859 

   860         rev = next(gen)

   861         self.assertEqual(rev.node, node0)

   862         self.assertEqual(rev.p1node, nullid)

   863         self.assertEqual(rev.p2node, nullid)

   864         # Delta behavior is storage dependent, so we can't easily test it.

   865 

   866         with self.assertRaises(StopIteration):

   867             next(gen)

   868 

   869         # assumehaveparentrevisions=False (the default) won't send a delta for

   870         # the first revision.

   871         gen = f.emitrevisions({node2, node1}, revisiondata=True)

   872 

   873         rev = next(gen)

   874         self.assertEqual(rev.node, node1)

   875         self.assertEqual(rev.p1node, node0)

   876         self.assertEqual(rev.p2node, nullid)

   877         self.assertEqual(rev.basenode, nullid)

   878         self.assertIsNone(rev.baserevisionsize)

   879         self.assertEqual(rev.revision, fulltext1)

   880         self.assertIsNone(rev.delta)

   881 

   882         rev = next(gen)

   883         self.assertEqual(rev.node, node2)

   884         self.assertEqual(rev.p1node, node1)

   885         self.assertEqual(rev.p2node, nullid)

   886         self.assertEqual(rev.basenode, node1)

   887         self.assertIsNone(rev.baserevisionsize)

   888         self.assertIsNone(rev.revision)

   889         self.assertEqual(rev.delta,

   890                          b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' +

   891                          fulltext2)

   892 

   893         with self.assertRaises(StopIteration):

   894             next(gen)

   895 

   896         # assumehaveparentrevisions=True allows delta against initial revision.

   897         gen = f.emitrevisions([node2, node1],

   898                               revisiondata=True, assumehaveparentrevisions=True)

   899 

   900         rev = next(gen)

   901         self.assertEqual(rev.node, node1)

   902         self.assertEqual(rev.p1node, node0)

   903         self.assertEqual(rev.p2node, nullid)

   904         self.assertEqual(rev.basenode, node0)

   905         self.assertIsNone(rev.baserevisionsize)

   906         self.assertIsNone(rev.revision)

   907         self.assertEqual(rev.delta,

   908                          b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' +

   909                          fulltext1)

   910 

   911         # forceprevious=True forces a delta against the previous revision.

   912         # Special case for initial revision.

   913         gen = f.emitrevisions([node0], revisiondata=True, deltaprevious=True)

   914 

   915         rev = next(gen)

   916         self.assertEqual(rev.node, node0)

   917         self.assertEqual(rev.p1node, nullid)

   918         self.assertEqual(rev.p2node, nullid)

   919         self.assertEqual(rev.basenode, nullid)

   920         self.assertIsNone(rev.baserevisionsize)

   921         self.assertIsNone(rev.revision)

   922         self.assertEqual(rev.delta,

   923                          b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' +

   924                          fulltext0)

   925 

   926         with self.assertRaises(StopIteration):

   927             next(gen)

   928 

   929         gen = f.emitrevisions([node0, node2], revisiondata=True,

   930                               deltaprevious=True)

   931 

   932         rev = next(gen)

   933         self.assertEqual(rev.node, node0)

   934         self.assertEqual(rev.p1node, nullid)

   935         self.assertEqual(rev.p2node, nullid)

   936         self.assertEqual(rev.basenode, nullid)

   937         self.assertIsNone(rev.baserevisionsize)

   938         self.assertIsNone(rev.revision)

   939         self.assertEqual(rev.delta,

   940                          b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' +

   941                          fulltext0)

   942 

   943         rev = next(gen)

   944         self.assertEqual(rev.node, node2)

   945         self.assertEqual(rev.p1node, node1)

   946         self.assertEqual(rev.p2node, nullid)

   947         self.assertEqual(rev.basenode, node0)

   948 

   949         with self.assertRaises(StopIteration):

   950             next(gen)

   951