tests/test-rust-discovery.py
changeset 42217 13b64247f48f
child 42218 1b0be75cb61f
equal deleted inserted replaced
42216:10b465d61556 42217:13b64247f48f
       
     1 from __future__ import absolute_import
       
     2 import unittest
       
     3 
       
     4 try:
       
     5     from mercurial import rustext
       
     6     rustext.__name__  # trigger immediate actual import
       
     7 except ImportError:
       
     8     rustext = None
       
     9 else:
       
    10     # this would fail already without appropriate ancestor.__package__
       
    11     from mercurial.rustext.discovery import (
       
    12         PartialDiscovery,
       
    13     )
       
    14 
       
    15 try:
       
    16     from mercurial.cext import parsers as cparsers
       
    17 except ImportError:
       
    18     cparsers = None
       
    19 
       
    20 # picked from test-parse-index2, copied rather than imported
       
    21 # so that it stays stable even if test-parse-index2 changes or disappears.
       
    22 data_non_inlined = (
       
    23     b'\x00\x00\x00\x01\x00\x00\x00\x00\x00\x01D\x19'
       
    24     b'\x00\x07e\x12\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff'
       
    25     b'\xff\xff\xff\xff\xd1\xf4\xbb\xb0\xbe\xfc\x13\xbd\x8c\xd3\x9d'
       
    26     b'\x0f\xcd\xd9;\x8c\x07\x8cJ/\x00\x00\x00\x00\x00\x00\x00\x00\x00'
       
    27     b'\x00\x00\x00\x00\x00\x00\x01D\x19\x00\x00\x00\x00\x00\xdf\x00'
       
    28     b'\x00\x01q\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\xff'
       
    29     b'\xff\xff\xff\xc1\x12\xb9\x04\x96\xa4Z1t\x91\xdfsJ\x90\xf0\x9bh'
       
    30     b'\x07l&\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
       
    31     b'\x00\x01D\xf8\x00\x00\x00\x00\x01\x1b\x00\x00\x01\xb8\x00\x00'
       
    32     b'\x00\x01\x00\x00\x00\x02\x00\x00\x00\x01\xff\xff\xff\xff\x02\n'
       
    33     b'\x0e\xc6&\xa1\x92\xae6\x0b\x02i\xfe-\xe5\xbao\x05\xd1\xe7\x00'
       
    34     b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01F'
       
    35     b'\x13\x00\x00\x00\x00\x01\xec\x00\x00\x03\x06\x00\x00\x00\x01'
       
    36     b'\x00\x00\x00\x03\x00\x00\x00\x02\xff\xff\xff\xff\x12\xcb\xeby1'
       
    37     b'\xb6\r\x98B\xcb\x07\xbd`\x8f\x92\xd9\xc4\x84\xbdK\x00\x00\x00'
       
    38     b'\x00\x00\x00\x00\x00\x00\x00\x00\x00'
       
    39     )
       
    40 
       
    41 
       
    42 @unittest.skipIf(rustext is None or cparsers is None,
       
    43                  "rustext or the C Extension parsers module "
       
    44                  "discovery relies on is not available")
       
    45 class rustdiscoverytest(unittest.TestCase):
       
    46     """Test the correctness of binding to Rust code.
       
    47 
       
    48     This test is merely for the binding to Rust itself: extraction of
       
    49     Python variable, giving back the results etc.
       
    50 
       
    51     It is not meant to test the algorithmic correctness of the provided
       
    52     methods. Hence the very simple embedded index data is good enough.
       
    53 
       
    54     Algorithmic correctness is asserted by the Rust unit tests.
       
    55     """
       
    56 
       
    57     def parseindex(self):
       
    58         return cparsers.parse_index2(data_non_inlined, False)[0]
       
    59 
       
    60     def testindex(self):
       
    61         idx = self.parseindex()
       
    62         # checking our assumptions about the index binary data:
       
    63         self.assertEqual({i: (r[5], r[6]) for i, r in enumerate(idx)},
       
    64                          {0: (-1, -1),
       
    65                           1: (0, -1),
       
    66                           2: (1, -1),
       
    67                           3: (2, -1)})
       
    68 
       
    69     def testaddcommonsmissings(self):
       
    70         idx = self.parseindex()
       
    71         disco = PartialDiscovery(idx, [3])
       
    72         self.assertFalse(disco.hasinfo())
       
    73         self.assertFalse(disco.iscomplete())
       
    74 
       
    75         disco.addcommons([1])
       
    76         self.assertTrue(disco.hasinfo())
       
    77         self.assertFalse(disco.iscomplete())
       
    78 
       
    79         disco.addmissings([2])
       
    80         self.assertTrue(disco.hasinfo())
       
    81         self.assertTrue(disco.iscomplete())
       
    82 
       
    83         self.assertEqual(disco.commonheads(), {1})
       
    84 
       
    85     def testaddinfocommonfirst(self):
       
    86         idx = self.parseindex()
       
    87         disco = PartialDiscovery(idx, [3])
       
    88         disco.addinfo([(1, True), (2, False)])
       
    89         self.assertTrue(disco.hasinfo())
       
    90         self.assertTrue(disco.iscomplete())
       
    91         self.assertEqual(disco.commonheads(), {1})
       
    92 
       
    93     def testaddinfomissingfirst(self):
       
    94         idx = self.parseindex()
       
    95         disco = PartialDiscovery(idx, [3])
       
    96         disco.addinfo([(2, False), (1, True)])
       
    97         self.assertTrue(disco.hasinfo())
       
    98         self.assertTrue(disco.iscomplete())
       
    99         self.assertEqual(disco.commonheads(), {1})
       
   100 
       
   101 if __name__ == '__main__':
       
   102     import silenttestrunner
       
   103     silenttestrunner.main(__name__)