tests/test-annotate.py

tests: avoid referring to pvec in demandimport test

Nothing else currently uses pvec, so we may want to delete it (but
Augie Fackler says he may want to use it). To enable deletion, this
patch replaces it by the error module in the demandimport test (any
module works). However, since the error module had already been loaded
at this point in the test (via the util module), I moved it earlier in
the test so it's still not loaded (although I'm not sure if that's
even relevant to the test).

Differential Revision: https://phab.mercurial-scm.org/D2287

from __future__ import absolute_import
from __future__ import print_function

import unittest

from mercurial import (
    mdiff,
)
from mercurial.context import (
    annotateline,
    _annotatepair,
)

class AnnotateTests(unittest.TestCase):
    """Unit tests for annotate code."""

    def testannotatepair(self):
        self.maxDiff = None # camelcase-required

        oldfctx = b'old'
        p1fctx, p2fctx, childfctx = b'p1', b'p2', b'c'
        olddata = b'a\nb\n'
        p1data = b'a\nb\nc\n'
        p2data = b'a\nc\nd\n'
        childdata = b'a\nb2\nc\nc2\nd\n'
        diffopts = mdiff.diffopts()

        def decorate(text, rev):
            return ([annotateline(fctx=rev, lineno=i)
                     for i in range(1, text.count(b'\n') + 1)],
                    text)

        # Basic usage

        oldann = decorate(olddata, oldfctx)
        p1ann = decorate(p1data, p1fctx)
        p1ann = _annotatepair([oldann], p1fctx, p1ann, False, diffopts)
        self.assertEqual(p1ann[0], [
            annotateline(b'old', 1),
            annotateline(b'old', 2),
            annotateline(b'p1', 3),
        ])

        p2ann = decorate(p2data, p2fctx)
        p2ann = _annotatepair([oldann], p2fctx, p2ann, False, diffopts)
        self.assertEqual(p2ann[0], [
            annotateline(b'old', 1),
            annotateline(b'p2', 2),
            annotateline(b'p2', 3),
        ])

        # Test with multiple parents (note the difference caused by ordering)

        childann = decorate(childdata, childfctx)
        childann = _annotatepair([p1ann, p2ann], childfctx, childann, False,
                                 diffopts)
        self.assertEqual(childann[0], [
            annotateline(b'old', 1),
            annotateline(b'c', 2),
            annotateline(b'p2', 2),
            annotateline(b'c', 4),
            annotateline(b'p2', 3),
        ])

        childann = decorate(childdata, childfctx)
        childann = _annotatepair([p2ann, p1ann], childfctx, childann, False,
                                 diffopts)
        self.assertEqual(childann[0], [
            annotateline(b'old', 1),
            annotateline(b'c', 2),
            annotateline(b'p1', 3),
            annotateline(b'c', 4),
            annotateline(b'p2', 3),
        ])

        # Test with skipchild (note the difference caused by ordering)

        childann = decorate(childdata, childfctx)
        childann = _annotatepair([p1ann, p2ann], childfctx, childann, True,
                                 diffopts)
        self.assertEqual(childann[0], [
            annotateline(b'old', 1),
            annotateline(b'old', 2, True),
            # note that this line was carried over from earlier so it is *not*
            # marked skipped
            annotateline(b'p2', 2),
            annotateline(b'p2', 2, True),
            annotateline(b'p2', 3),
        ])

        childann = decorate(childdata, childfctx)
        childann = _annotatepair([p2ann, p1ann], childfctx, childann, True,
                                 diffopts)
        self.assertEqual(childann[0], [
            annotateline(b'old', 1),
            annotateline(b'old', 2, True),
            annotateline(b'p1', 3),
            annotateline(b'p1', 3, True),
            annotateline(b'p2', 3),
        ])

if __name__ == '__main__':
    import silenttestrunner
    silenttestrunner.main(__name__)