depot_tools/tests/git_hyper_blame_test.py

#!/usr/bin/env vpython3
# Copyright 2016 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Tests for git_dates."""

from io import BytesIO, StringIO
import os
import re
import shutil
import sys
import tempfile
from unittest import mock

DEPOT_TOOLS_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, DEPOT_TOOLS_ROOT)

from testing_support import coverage_utils
from testing_support import git_test_utils

import gclient_utils

GitRepo = git_test_utils.GitRepo

# TODO: Should fix these warnings.
# pylint: disable=line-too-long


class GitHyperBlameTestBase(git_test_utils.GitRepoReadOnlyTestBase):
    @classmethod
    def setUpClass(cls):
        super(GitHyperBlameTestBase, cls).setUpClass()
        import git_hyper_blame
        cls.git_hyper_blame = git_hyper_blame

    def setUp(self):
        mock.patch('sys.stderr', StringIO()).start()
        self.addCleanup(mock.patch.stopall)

    def run_hyperblame(self, ignored, filename, revision):
        outbuf = BytesIO()
        ignored = [self.repo[c] for c in ignored]
        retval = self.repo.run(self.git_hyper_blame.hyper_blame, outbuf,
                               ignored, filename, revision)
        return retval, outbuf.getvalue().rstrip().split(b'\n')

    def blame_line(self, commit_name, rest, author=None, filename=None):
        """Generate a blame line from a commit.

        Args:
            commit_name: The commit's schema name.
            rest: The blame line after the timestamp. e.g., '2) file2 - merged'.
            author: The author's name. If omitted, reads the name out of the commit.
            filename: The filename. If omitted, not shown in the blame line.
        """
        short = self.repo[commit_name][:8]
        start = '%s %s' % (short, filename) if filename else short
        if author is None:
            author = self.repo.show_commit(commit_name, format_string='%an %ai')
        else:
            author += self.repo.show_commit(commit_name, format_string=' %ai')
        return ('%s (%s %s' % (start, author, rest)).encode('utf-8')


class GitHyperBlameMainTest(GitHyperBlameTestBase):
    """End-to-end tests on a very simple repo."""
    REPO_SCHEMA = "A B C D"

    COMMIT_A = {
        'some/files/file': {
            'data': b'line 1\nline 2\n'
        },
    }

    COMMIT_B = {
        'some/files/file': {
            'data': b'line 1\nline 2.1\n'
        },
    }

    COMMIT_C = {
        'some/files/file': {
            'data': b'line 1.1\nline 2.1\n'
        },
    }

    COMMIT_D = {
        # This file should be automatically considered for ignore.
        '.git-blame-ignore-revs': {
            'data': b'tag_C'
        },
        # This file should not be considered.
        'some/files/.git-blame-ignore-revs': {
            'data': b'tag_B'
        },
    }

    def setUp(self):
        super(GitHyperBlameMainTest, self).setUp()
        # Most tests want to check out C (so the .git-blame-ignore-revs is not
        # used).
        self.repo.git('checkout', '-f', 'tag_C')

    def testBasicBlame(self):
        """Tests the main function (simple end-to-end test with no ignores)."""
        expected_output = [
            self.blame_line('C', '1) line 1.1'),
            self.blame_line('B', '2) line 2.1')
        ]
        outbuf = BytesIO()
        retval = self.repo.run(self.git_hyper_blame.main,
                               ['tag_C', 'some/files/file'], outbuf)
        self.assertEqual(0, retval)
        self.assertEqual(expected_output,
                         outbuf.getvalue().rstrip().split(b'\n'))
        self.assertEqual('', sys.stderr.getvalue())

    def testIgnoreSimple(self):
        """Tests the main function (simple end-to-end test with ignores)."""
        expected_output = [
            self.blame_line('C', ' 1) line 1.1'),
            self.blame_line('A', '2*) line 2.1')
        ]
        outbuf = BytesIO()
        retval = self.repo.run(self.git_hyper_blame.main,
                               ['-i', 'tag_B', 'tag_C', 'some/files/file'],
                               outbuf)
        self.assertEqual(0, retval)
        self.assertEqual(expected_output,
                         outbuf.getvalue().rstrip().split(b'\n'))
        self.assertEqual('', sys.stderr.getvalue())

    def testBadRepo(self):
        """Tests the main function (not in a repo)."""
        # Make a temp dir that has no .git directory.
        curdir = os.getcwd()
        tempdir = tempfile.mkdtemp(suffix='_nogit', prefix='git_repo')
        try:
            os.chdir(tempdir)
            outbuf = BytesIO()
            retval = self.git_hyper_blame.main(
                ['-i', 'tag_B', 'tag_C', 'some/files/file'], outbuf)
        finally:
            os.chdir(curdir)
            shutil.rmtree(tempdir)

        self.assertNotEqual(0, retval)
        self.assertEqual(b'', outbuf.getvalue())
        r = re.compile('^fatal: Not a git repository', re.I)
        self.assertRegexpMatches(sys.stderr.getvalue(), r)

    def testBadFilename(self):
        """Tests the main function (bad filename)."""
        outbuf = BytesIO()
        retval = self.repo.run(self.git_hyper_blame.main,
                               ['-i', 'tag_B', 'tag_C', 'some/files/xxxx'],
                               outbuf)
        self.assertNotEqual(0, retval)
        self.assertEqual(b'', outbuf.getvalue())
        # TODO(mgiuca): This test used to test the exact string, but it broke
        # due to an upstream bug in git-blame. For now, just check the start of
        # the string. A patch has been sent upstream; when it rolls out we can
        # revert back to the original test logic.
        self.assertTrue(sys.stderr.getvalue().startswith(
            'fatal: no such path some/files/xxxx in '))

    def testBadRevision(self):
        """Tests the main function (bad revision to blame from)."""
        outbuf = BytesIO()
        retval = self.repo.run(self.git_hyper_blame.main,
                               ['-i', 'tag_B', 'xxxx', 'some/files/file'],
                               outbuf)
        self.assertNotEqual(0, retval)
        self.assertEqual(b'', outbuf.getvalue())
        self.assertRegexpMatches(
            sys.stderr.getvalue(),
            '^fatal: ambiguous argument \'xxxx\': unknown '
            'revision or path not in the working tree.')

    def testBadIgnore(self):
        """Tests the main function (bad revision passed to -i)."""
        expected_output = [
            self.blame_line('C', '1) line 1.1'),
            self.blame_line('B', '2) line 2.1')
        ]
        outbuf = BytesIO()
        retval = self.repo.run(self.git_hyper_blame.main,
                               ['-i', 'xxxx', 'tag_C', 'some/files/file'],
                               outbuf)
        self.assertEqual(0, retval)
        self.assertEqual(expected_output,
                         outbuf.getvalue().rstrip().split(b'\n'))
        self.assertEqual('warning: unknown revision \'xxxx\'.\n',
                         sys.stderr.getvalue())

    def testIgnoreFile(self):
        """Tests passing the ignore list in a file."""
        expected_output = [
            self.blame_line('C', ' 1) line 1.1'),
            self.blame_line('A', '2*) line 2.1')
        ]
        outbuf = BytesIO()

        with gclient_utils.temporary_file() as ignore_file:
            gclient_utils.FileWrite(
                ignore_file, '# Line comments are allowed.\n'
                '\n'
                '{}\n'
                'xxxx\n'.format(self.repo['B']))
            retval = self.repo.run(
                self.git_hyper_blame.main,
                ['--ignore-file', ignore_file, 'tag_C', 'some/files/file'],
                outbuf)

        self.assertEqual(0, retval)
        self.assertEqual(expected_output,
                         outbuf.getvalue().rstrip().split(b'\n'))
        self.assertEqual('warning: unknown revision \'xxxx\'.\n',
                         sys.stderr.getvalue())

    def testDefaultIgnoreFile(self):
        """Tests automatically using a default ignore list."""
        # Check out revision D. We expect the script to use the default ignore
        # list that is checked out, *not* the one committed at the given
        # revision.
        self.repo.git('checkout', '-f', 'tag_D')

        expected_output = [
            self.blame_line('A', '1*) line 1.1'),
            self.blame_line('B', ' 2) line 2.1')
        ]
        outbuf = BytesIO()

        retval = self.repo.run(self.git_hyper_blame.main,
                               ['tag_D', 'some/files/file'], outbuf)

        self.assertEqual(0, retval)
        self.assertEqual(expected_output,
                         outbuf.getvalue().rstrip().split(b'\n'))
        self.assertEqual('', sys.stderr.getvalue())

        # Test blame from a different revision. Despite the default ignore file
        # *not* being committed at that revision, it should still be picked up
        # because D is currently checked out.
        outbuf = BytesIO()

        retval = self.repo.run(self.git_hyper_blame.main,
                               ['tag_C', 'some/files/file'], outbuf)

        self.assertEqual(0, retval)
        self.assertEqual(expected_output,
                         outbuf.getvalue().rstrip().split(b'\n'))
        self.assertEqual('', sys.stderr.getvalue())

    def testNoDefaultIgnores(self):
        """Tests the --no-default-ignores switch."""
        # Check out revision D. This has a .git-blame-ignore-revs file, which we
        # expect to be ignored due to --no-default-ignores.
        self.repo.git('checkout', '-f', 'tag_D')

        expected_output = [
            self.blame_line('C', '1) line 1.1'),
            self.blame_line('B', '2) line 2.1')
        ]
        outbuf = BytesIO()

        retval = self.repo.run(
            self.git_hyper_blame.main,
            ['tag_D', 'some/files/file', '--no-default-ignores'], outbuf)

        self.assertEqual(0, retval)
        self.assertEqual(expected_output,
                         outbuf.getvalue().rstrip().split(b'\n'))
        self.assertEqual('', sys.stderr.getvalue())


class GitHyperBlameSimpleTest(GitHyperBlameTestBase):
    REPO_SCHEMA = """
  A B D E F G H
  A C D
  """

    COMMIT_A = {
        'some/files/file1': {
            'data': b'file1'
        },
        'some/files/file2': {
            'data': b'file2'
        },
        'some/files/empty': {
            'data': b''
        },
        'some/other/file': {
            'data': b'otherfile'
        },
    }

    COMMIT_B = {
        'some/files/file2': {
            'mode': 0o755,
            'data': b'file2 - vanilla\n'
        },
        'some/files/empty': {
            'data': b'not anymore'
        },
        'some/files/file3': {
            'data': b'file3'
        },
    }

    COMMIT_C = {
        'some/files/file2': {
            'data': b'file2 - merged\n'
        },
    }

    COMMIT_D = {
        'some/files/file2': {
            'data': b'file2 - vanilla\nfile2 - merged\n'
        },
    }

    COMMIT_E = {
        'some/files/file2': {
            'data': b'file2 - vanilla\nfile_x - merged\n'
        },
    }

    COMMIT_F = {
        'some/files/file2': {
            'data': b'file2 - vanilla\nfile_y - merged\n'
        },
    }

    # Move file2 from files to other.
    COMMIT_G = {
        'some/files/file2': {
            'data': None
        },
        'some/other/file2': {
            'data': b'file2 - vanilla\nfile_y - merged\n'
        },
    }

    COMMIT_H = {
        'some/other/file2': {
            'data': b'file2 - vanilla\nfile_z - merged\n'
        },
    }

    def testBlameError(self):
        """Tests a blame on a non-existent file."""
        expected_output = [b'']
        retval, output = self.run_hyperblame([], 'some/other/file2', 'tag_D')
        self.assertNotEqual(0, retval)
        self.assertEqual(expected_output, output)

    def testBlameEmpty(self):
        """Tests a blame of an empty file with no ignores."""
        expected_output = [b'']
        retval, output = self.run_hyperblame([], 'some/files/empty', 'tag_A')
        self.assertEqual(0, retval)
        self.assertEqual(expected_output, output)

    def testBasicBlame(self):
        """Tests a basic blame with no ignores."""
        # Expect to blame line 1 on B, line 2 on C.
        expected_output = [
            self.blame_line('B', '1) file2 - vanilla'),
            self.blame_line('C', '2) file2 - merged')
        ]
        retval, output = self.run_hyperblame([], 'some/files/file2', 'tag_D')
        self.assertEqual(0, retval)
        self.assertEqual(expected_output, output)

    def testBlameRenamed(self):
        """Tests a blame with no ignores on a renamed file."""
        # Expect to blame line 1 on B, line 2 on H.
        # Because the file has a different name than it had when (some of) these
        # lines were changed, expect the filenames to be displayed.
        expected_output = [
            self.blame_line('B',
                            '1) file2 - vanilla',
                            filename='some/files/file2'),
            self.blame_line('H',
                            '2) file_z - merged',
                            filename='some/other/file2')
        ]
        retval, output = self.run_hyperblame([], 'some/other/file2', 'tag_H')
        self.assertEqual(0, retval)
        self.assertEqual(expected_output, output)

    def testIgnoreSimpleEdits(self):
        """Tests a blame with simple (line-level changes) commits ignored."""
        # Expect to blame line 1 on B, line 2 on E.
        expected_output = [
            self.blame_line('B', '1) file2 - vanilla'),
            self.blame_line('E', '2) file_x - merged')
        ]
        retval, output = self.run_hyperblame([], 'some/files/file2', 'tag_E')
        self.assertEqual(0, retval)
        self.assertEqual(expected_output, output)

        # Ignore E; blame line 1 on B, line 2 on C.
        expected_output = [
            self.blame_line('B', ' 1) file2 - vanilla'),
            self.blame_line('C', '2*) file_x - merged')
        ]
        retval, output = self.run_hyperblame(['E'], 'some/files/file2', 'tag_E')
        self.assertEqual(0, retval)
        self.assertEqual(expected_output, output)

        # Ignore E and F; blame line 1 on B, line 2 on C.
        expected_output = [
            self.blame_line('B', ' 1) file2 - vanilla'),
            self.blame_line('C', '2*) file_y - merged')
        ]
        retval, output = self.run_hyperblame(['E', 'F'], 'some/files/file2',
                                             'tag_F')
        self.assertEqual(0, retval)
        self.assertEqual(expected_output, output)

    def testIgnoreInitialCommit(self):
        """Tests a blame with the initial commit ignored."""
        # Ignore A. Expect A to get blamed anyway.
        expected_output = [self.blame_line('A', '1) file1')]
        retval, output = self.run_hyperblame(['A'], 'some/files/file1', 'tag_A')
        self.assertEqual(0, retval)
        self.assertEqual(expected_output, output)

    def testIgnoreFileAdd(self):
        """Tests a blame ignoring the commit that added this file."""
        # Ignore A. Expect A to get blamed anyway.
        expected_output = [self.blame_line('B', '1) file3')]
        retval, output = self.run_hyperblame(['B'], 'some/files/file3', 'tag_B')
        self.assertEqual(0, retval)
        self.assertEqual(expected_output, output)

    def testIgnoreFilePopulate(self):
        """Tests a blame ignoring the commit that added data to an empty file."""
        # Ignore A. Expect A to get blamed anyway.
        expected_output = [self.blame_line('B', '1) not anymore')]
        retval, output = self.run_hyperblame(['B'], 'some/files/empty', 'tag_B')
        self.assertEqual(0, retval)
        self.assertEqual(expected_output, output)


class GitHyperBlameLineMotionTest(GitHyperBlameTestBase):
    REPO_SCHEMA = """
  A B C D E F
  """

    COMMIT_A = {
        'file': {
            'data': b'A\ngreen\nblue\n'
        },
    }

    # Change "green" to "yellow".
    COMMIT_B = {
        'file': {
            'data': b'A\nyellow\nblue\n'
        },
    }

    # Insert 2 lines at the top,
    # Change "yellow" to "red".
    # Insert 1 line at the bottom.
    COMMIT_C = {
        'file': {
            'data': b'X\nY\nA\nred\nblue\nZ\n'
        },
    }

    # Insert 2 more lines at the top.
    COMMIT_D = {
        'file': {
            'data': b'earth\nfire\nX\nY\nA\nred\nblue\nZ\n'
        },
    }

    # Insert a line before "red", and indent "red" and "blue".
    COMMIT_E = {
        'file': {
            'data': b'earth\nfire\nX\nY\nA\ncolors:\n red\n blue\nZ\n'
        },
    }

    # Insert a line between "A" and "colors".
    COMMIT_F = {
        'file': {
            'data': b'earth\nfire\nX\nY\nA\nB\ncolors:\n red\n blue\nZ\n'
        },
    }

    def testCacheDiffHunks(self):
        """Tests the cache_diff_hunks internal function."""
        expected_hunks = [
            ((0, 0), (1, 2)),
            ((2, 1), (4, 1)),
            ((3, 0), (6, 1)),
        ]
        hunks = self.repo.run(self.git_hyper_blame.cache_diff_hunks, 'tag_B',
                              'tag_C')
        self.assertEqual(expected_hunks, hunks)

    def testApproxLinenoAcrossRevs(self):
        """Tests the approx_lineno_across_revs internal function."""
        # Note: For all of these tests, the "old revision" and "new revision"
        # are reversed, which matches the usage by hyper_blame.

        # Test an unchanged line before any hunks in the diff. Should be
        # unchanged.
        lineno = self.repo.run(self.git_hyper_blame.approx_lineno_across_revs,
                               'file', 'file', 'tag_B', 'tag_A', 1)
        self.assertEqual(1, lineno)

        # Test an unchanged line after all hunks in the diff. Should be matched
        # to the line's previous position in the file.
        lineno = self.repo.run(self.git_hyper_blame.approx_lineno_across_revs,
                               'file', 'file', 'tag_D', 'tag_C', 6)
        self.assertEqual(4, lineno)

        # Test a line added in a new hunk. Should be matched to the line
        # *before* where the hunk was inserted in the old version of the file.
        lineno = self.repo.run(self.git_hyper_blame.approx_lineno_across_revs,
                               'file', 'file', 'tag_F', 'tag_E', 6)
        self.assertEqual(5, lineno)

        # Test lines added in a new hunk at the very start of the file. This
        # tests an edge case: normally it would be matched to the line *before*
        # where the hunk was inserted (Line 0), but since the hunk is at the
        # start of the file, we match to Line 1.
        lineno = self.repo.run(self.git_hyper_blame.approx_lineno_across_revs,
                               'file', 'file', 'tag_C', 'tag_B', 1)
        self.assertEqual(1, lineno)
        lineno = self.repo.run(self.git_hyper_blame.approx_lineno_across_revs,
                               'file', 'file', 'tag_C', 'tag_B', 2)
        self.assertEqual(1, lineno)

        # Test an unchanged line in between hunks in the diff. Should be matched
        # to the line's previous position in the file.
        lineno = self.repo.run(self.git_hyper_blame.approx_lineno_across_revs,
                               'file', 'file', 'tag_C', 'tag_B', 3)
        self.assertEqual(1, lineno)

        # Test a changed line. Should be matched to the hunk's previous position
        # in the file.
        lineno = self.repo.run(self.git_hyper_blame.approx_lineno_across_revs,
                               'file', 'file', 'tag_C', 'tag_B', 4)
        self.assertEqual(2, lineno)

        # Test a line added in a new hunk at the very end of the file. Should be
        # matched to the line *before* where the hunk was inserted (the last
        # line of the file). Technically same as the case above but good to
        # boundary test.
        lineno = self.repo.run(self.git_hyper_blame.approx_lineno_across_revs,
                               'file', 'file', 'tag_C', 'tag_B', 6)
        self.assertEqual(3, lineno)

    def testInterHunkLineMotion(self):
        """Tests a blame with line motion in another hunk in the ignored commit."""
        # Blame from D, ignoring C.

        # Lines 1, 2 were added by D.
        # Lines 3, 4 were added by C (but ignored, so blame A).
        # Line 5 was added by A.
        # Line 6 was modified by C (but ignored, so blame B). (Note: This
        # requires the algorithm to figure out that Line 6 in D == Line 4 in C
        # ~= Line 2 in B, so it blames B. Otherwise, it would blame A.) Line 7
        # was added by A. Line 8 was added by C (but ignored, so blame A).
        expected_output = [
            self.blame_line('D', ' 1) earth'),
            self.blame_line('D', ' 2) fire'),
            self.blame_line('A', '3*) X'),
            self.blame_line('A', '4*) Y'),
            self.blame_line('A', ' 5) A'),
            self.blame_line('B', '6*) red'),
            self.blame_line('A', ' 7) blue'),
            self.blame_line('A', '8*) Z'),
        ]
        retval, output = self.run_hyperblame(['C'], 'file', 'tag_D')
        self.assertEqual(0, retval)
        self.assertEqual(expected_output, output)

    def testIntraHunkLineMotion(self):
        """Tests a blame with line motion in the same hunk in the ignored commit."""
        # This test was mostly written as a demonstration of the limitations of
        # the current algorithm (it exhibits non-ideal behaviour).

        # Blame from E, ignoring E.
        # Line 6 was added by E (but ignored, so blame C).
        # Lines 7, 8 were modified by E (but ignored, so blame A).
        # TODO(mgiuca): Ideally, this would blame Line 7 on C, because the line
        # "red" was added by C, and this is just a small change to that line.
        # But the current algorithm can't deal with line motion within a hunk,
        # so it just assumes Line 7 in E ~= Line 7 in D == Line 3 in A (which
        # was "blue").
        expected_output = [
            self.blame_line('D', ' 1) earth'),
            self.blame_line('D', ' 2) fire'),
            self.blame_line('C', ' 3) X'),
            self.blame_line('C', ' 4) Y'),
            self.blame_line('A', ' 5) A'),
            self.blame_line('C', '6*) colors:'),
            self.blame_line('A', '7*)  red'),
            self.blame_line('A', '8*)  blue'),
            self.blame_line('C', ' 9) Z'),
        ]
        retval, output = self.run_hyperblame(['E'], 'file', 'tag_E')
        self.assertEqual(0, retval)
        self.assertEqual(expected_output, output)


class GitHyperBlameLineNumberTest(GitHyperBlameTestBase):
    REPO_SCHEMA = """
  A B C D
  """

    COMMIT_A = {
        'file': {
            'data': b'red\nblue\n'
        },
    }

    # Change "blue" to "green".
    COMMIT_B = {
        'file': {
            'data': b'red\ngreen\n'
        },
    }

    # Insert 2 lines at the top,
    COMMIT_C = {
        'file': {
            'data': b'\n\nred\ngreen\n'
        },
    }

    # Change "green" to "yellow".
    COMMIT_D = {
        'file': {
            'data': b'\n\nred\nyellow\n'
        },
    }

    def testTwoChangesWithAddedLines(self):
        """Regression test for https://crbug.com/709831.

        Tests a line with multiple ignored edits, and a line number change in
        between (such that the line number in the current revision is bigger than
        the file's line count at the older ignored revision).
        """
        expected_output = [
            self.blame_line('C', ' 1) '),
            self.blame_line('C', ' 2) '),
            self.blame_line('A', ' 3) red'),
            self.blame_line('A', '4*) yellow'),
        ]
        # Due to https://crbug.com/709831, ignoring both B and D would crash,
        # because of C (in between those revisions) which moves Line 2 to Line
        # 4. The algorithm would incorrectly think that Line 4 was still on Line
        # 4 in Commit B, even though it was Line 2 at that time. Its index is
        # out of range in the number of lines in Commit B.
        retval, output = self.run_hyperblame(['B', 'D'], 'file', 'tag_D')
        self.assertEqual(0, retval)
        self.assertEqual(expected_output, output)


class GitHyperBlameUnicodeTest(GitHyperBlameTestBase):
    REPO_SCHEMA = """
  A B C
  """

    COMMIT_A = {
        GitRepo.AUTHOR_NAME: 'ASCII Author',
        'file': {
            'data': b'red\nblue\n'
        },
    }

    # Add a line.
    COMMIT_B = {
        GitRepo.AUTHOR_NAME: '\u4e2d\u56fd\u4f5c\u8005',
        'file': {
            'data': b'red\ngreen\nblue\n'
        },
    }

    # Modify a line with non-UTF-8 author and file text.
    COMMIT_C = {
        GitRepo.AUTHOR_NAME: 'Lat\xedn-1 Author',
        'file': {
            'data': 'red\ngre\u00e9n\nblue\n'.encode('latin-1')
        },
    }

    def testNonUTF8Data(self):
        """Ensures correct behaviour even if author or file data is not UTF-8.

        There is no guarantee that a file will be UTF-8-encoded, so this is
        realistic.
        """
        expected_output = [
            self.blame_line('A', '1) red', author='ASCII Author  '),
            # The Author has been re-encoded as UTF-8. The file data is
            # converted to UTF8 and unknown characters replaced.
            self.blame_line('C', '2) gre\ufffdn', author='Lat\xedn-1 Author'),
            self.blame_line('A', '3) blue', author='ASCII Author  '),
        ]
        retval, output = self.run_hyperblame([], 'file', 'tag_C')
        self.assertEqual(0, retval)
        self.assertEqual(expected_output, output)


if __name__ == '__main__':
    sys.exit(
        coverage_utils.covered_main(
            os.path.join(DEPOT_TOOLS_ROOT, 'git_hyper_blame.py')))